diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/Android.mk b/tools/emulator/opengl/host/libs/Translator/EGL/Android.mk new file mode 100644 index 000000000..9d6321d09 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/Android.mk @@ -0,0 +1,48 @@ +LOCAL_PATH := $(call my-dir) + +### EGL host implementation ######################## +include $(CLEAR_VARS) + +translator_path := $(LOCAL_PATH)/.. + +OS_SRCS:= + + +ifeq ($(HOST_OS),linux) + OS_SRCS = EglX11Api.cpp + LOCAL_LDLIBS := -lX11 -lGL -ldl +endif + +ifeq ($(HOST_OS),darwin) + OS_SRCS = EglMacApi.cpp +endif + +ifeq ($(HOST_OS),windows) + OS_SRCS = EglWindowsApi.cpp +endif + +LOCAL_SRC_FILES := \ + $(OS_SRCS) \ + ThreadInfo.cpp \ + EglImp.cpp \ + EglConfig.cpp \ + EglContext.cpp \ + EglGlobalInfo.cpp \ + EglValidate.cpp \ + EglSurface.cpp \ + EglWindowSurface.cpp \ + EglPbufferSurface.cpp \ + EglPixmapSurface.cpp \ + EglThreadInfo.cpp \ + EglDisplay.cpp + + +LOCAL_C_INCLUDES += \ + $(translator_path)/include + +LOCAL_CFLAGS := -g -O0 +LOCAL_MODULE_TAGS := debug +LOCAL_MODULE := libEGL_translator +LOCAL_STATIC_LIBRARIES := libGLcommon libcutils +include $(BUILD_HOST_SHARED_LIBRARY) + diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglConfig.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglConfig.cpp new file mode 100644 index 000000000..609e2317f --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglConfig.cpp @@ -0,0 +1,284 @@ +/* +* Copyright (C) 2011 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 "EglConfig.h" + +EglConfig::EglConfig(EGLint red_size, + EGLint green_size, + EGLint blue_size, + EGLint alpha_size, + EGLenum caveat, + EGLint config_id, + EGLint depth_size, + EGLint frame_buffer_level, + EGLint max_pbuffer_width, + EGLint max_pbuffer_height, + EGLint max_pbuffer_size, + EGLBoolean native_renderable, + EGLint native_visual_id, + EGLint native_visual_type, + EGLint samples_per_pixel, + EGLint stencil_size, + EGLint surface_type, + EGLenum transparent_type, + EGLint trans_red_val, + EGLint trans_green_val, + EGLint trans_blue_val, + EGLNativePixelFormatType frmt): + + m_buffer_size(red_size + green_size + blue_size + alpha_size), + m_red_size(red_size), + m_green_size(green_size), + m_blue_size(blue_size), + m_alpha_size(alpha_size), + m_bind_to_tex_rgb(EGL_FALSE), //not supported for now + m_bind_to_tex_rgba(EGL_FALSE), //not supported for now + m_caveat(caveat), + m_config_id(config_id), + m_frame_buffer_level(frame_buffer_level), + m_depth_size(depth_size), + m_max_pbuffer_width(max_pbuffer_width), + m_max_pbuffer_height(max_pbuffer_height), + m_max_pbuffer_size(max_pbuffer_size), + m_max_swap_interval(MAX_SWAP_INTERVAL), + m_min_swap_interval(MIN_SWAP_INTERVAL), + m_native_renderable(native_renderable), + m_native_visual_id(native_visual_id), + m_native_visual_type(native_visual_type), + m_sample_buffers_num(samples_per_pixel > 0 ?1:0), + m_samples_per_pixel(samples_per_pixel), + m_stencil_size(stencil_size), + m_surface_type(surface_type), + m_transparent_type(transparent_type), + m_trans_red_val(trans_red_val), + m_trans_green_val(trans_green_val), + m_trans_blue_val(trans_blue_val), + m_nativeFormat(frmt){}; + + + EglConfig::EglConfig(const EglConfig& conf):m_buffer_size(conf.m_buffer_size), + m_red_size(conf.m_red_size), + m_green_size(conf.m_green_size), + m_blue_size(conf.m_blue_size), + m_alpha_size(conf.m_alpha_size), + m_bind_to_tex_rgb(conf.m_bind_to_tex_rgb), + m_bind_to_tex_rgba(conf.m_bind_to_tex_rgba), + m_caveat(conf.m_caveat), + m_config_id(conf.m_config_id), + m_frame_buffer_level(conf.m_frame_buffer_level), + m_depth_size(conf.m_depth_size), + m_max_pbuffer_width(conf.m_max_pbuffer_width), + m_max_pbuffer_height(conf.m_max_pbuffer_height), + m_max_pbuffer_size(conf.m_max_pbuffer_size), + m_max_swap_interval(conf.m_max_swap_interval), + m_min_swap_interval(conf.m_min_swap_interval), + m_native_renderable(conf.m_native_renderable), + m_native_visual_id(conf.m_native_visual_id), + m_native_visual_type(conf.m_native_visual_type), + m_sample_buffers_num(conf.m_sample_buffers_num), + m_samples_per_pixel(conf.m_samples_per_pixel), + m_stencil_size(conf.m_stencil_size), + m_surface_type(conf.m_surface_type), + m_transparent_type(conf.m_transparent_type), + m_trans_red_val(conf.m_trans_red_val), + m_trans_green_val(conf.m_trans_green_val), + m_trans_blue_val(conf.m_trans_blue_val), + m_nativeFormat(conf.m_nativeFormat){}; + + + +bool EglConfig::getConfAttrib(EGLint attrib,EGLint* val) const { + switch(attrib) { + case EGL_BUFFER_SIZE: + *val = m_buffer_size; + break; + case EGL_RED_SIZE: + *val = m_red_size; + break; + case EGL_GREEN_SIZE: + *val = m_green_size; + break; + case EGL_BLUE_SIZE: + *val = m_blue_size; + break; + case EGL_ALPHA_SIZE: + *val = m_alpha_size; + break; + case EGL_BIND_TO_TEXTURE_RGB: + *val = m_bind_to_tex_rgb; + break; + case EGL_BIND_TO_TEXTURE_RGBA: + *val = m_bind_to_tex_rgba; + break; + case EGL_CONFIG_CAVEAT: + *val = m_caveat; + break; + case EGL_CONFIG_ID: + *val = m_config_id; + break; + case EGL_DEPTH_SIZE: + *val = m_depth_size; + break; + case EGL_LEVEL: + *val = m_frame_buffer_level; + break; + case EGL_MAX_PBUFFER_WIDTH: + *val = m_max_pbuffer_width; + break; + case EGL_MAX_PBUFFER_HEIGHT: + *val = m_max_pbuffer_height; + break; + case EGL_MAX_PBUFFER_PIXELS: + *val = m_max_pbuffer_size; + break; + case EGL_MAX_SWAP_INTERVAL: + *val = m_max_swap_interval; + break; + case EGL_MIN_SWAP_INTERVAL: + *val = m_min_swap_interval; + break; + case EGL_NATIVE_RENDERABLE: + *val = m_native_renderable; + break; + case EGL_NATIVE_VISUAL_ID: + *val = m_native_visual_id; + break; + case EGL_NATIVE_VISUAL_TYPE: + *val = m_native_visual_type; + break; + case EGL_SAMPLE_BUFFERS: + *val = m_sample_buffers_num; + break; + case EGL_SAMPLES: + *val = m_samples_per_pixel; + break; + case EGL_STENCIL_SIZE: + *val = m_stencil_size; + break; + case EGL_SURFACE_TYPE: + *val = m_surface_type; + break; + case EGL_TRANSPARENT_TYPE: + *val =m_transparent_type; + break; + case EGL_TRANSPARENT_RED_VALUE: + *val = m_trans_red_val; + break; + case EGL_TRANSPARENT_GREEN_VALUE: + *val = m_trans_green_val; + break; + case EGL_TRANSPARENT_BLUE_VALUE: + *val = m_trans_blue_val; + break; + default: + return false; + } + return true; +} + +// checking compitabilty between *this configuration and another configuration +// the compitability is checked againsed red,green,blue,buffer stencil and depth sizes +bool EglConfig::compitableWith(const EglConfig& conf) const { + + if(m_buffer_size != conf.m_buffer_size) return false; + if(m_red_size != conf.m_red_size) return false; + if(m_green_size != conf.m_green_size) return false; + if(m_blue_size != conf.m_blue_size) return false; + if(m_depth_size != conf.m_depth_size) return false; + if(m_stencil_size != conf.m_stencil_size) return false; + + return true; +} + +//following the sorting EGLconfig as in spec +bool EglConfig::operator<(const EglConfig& conf) const { + //1 + if(m_caveat != conf.m_caveat) { + return m_caveat < conf.m_caveat; // EGL_NONE < EGL_SLOW_CONFIG < EGL_NON_CONFORMANT_CONFIG + } + //2 TODO: + + //3 + if(m_buffer_size != conf.m_buffer_size) { + return m_buffer_size < conf.m_buffer_size; + } + //4 + if(m_sample_buffers_num != conf.m_sample_buffers_num) { + return m_sample_buffers_num < conf.m_sample_buffers_num; + } + //5 + if(m_samples_per_pixel != conf.m_samples_per_pixel) { + return m_samples_per_pixel < conf.m_samples_per_pixel; + } + //6 + if(m_depth_size != conf.m_depth_size) { + return m_depth_size < conf.m_depth_size; + } + //7 + if(m_stencil_size != conf.m_stencil_size) { + return m_stencil_size < conf.m_stencil_size; + } + //8 implementation defined + if(m_native_visual_type != conf.m_native_visual_type) { + return m_native_visual_type < conf.m_native_visual_type; + } + //9 + return m_config_id < conf.m_config_id; +} + +bool EglConfig::operator>=(const EglConfig& conf) const { + return !((*this) < conf); +} +#define CHECK_PROP(dummy,prop_name,op) \ + if((dummy.prop_name != EGL_DONT_CARE) && (dummy.prop_name op prop_name)) return false; +#define CHECK_PROP_CAST(dummy,prop_name,op) \ + if((((EGLint)dummy.prop_name) != EGL_DONT_CARE) && (dummy.prop_name op prop_name)) return false; +//checking if config stands for all the selection crateria of dummy as defined by EGL spec +bool EglConfig::choosen(const EglConfig& dummy) { + + //atleast + CHECK_PROP(dummy,m_buffer_size,>); + CHECK_PROP(dummy,m_red_size,>); + CHECK_PROP(dummy,m_green_size,>); + CHECK_PROP(dummy,m_blue_size,>); + CHECK_PROP(dummy,m_alpha_size,>); + CHECK_PROP(dummy,m_depth_size,>); + CHECK_PROP(dummy,m_stencil_size,>); + CHECK_PROP(dummy,m_sample_buffers_num,>); + CHECK_PROP(dummy,m_samples_per_pixel,>); + + //exact + CHECK_PROP(dummy,m_frame_buffer_level,!=); + CHECK_PROP(dummy,m_config_id,!=); + CHECK_PROP(dummy,m_native_visual_type,!=); + CHECK_PROP(dummy,m_max_swap_interval ,!=); + CHECK_PROP(dummy,m_min_swap_interval ,!=); + CHECK_PROP(dummy,m_trans_red_val ,!=); + CHECK_PROP(dummy,m_trans_green_val ,!=); + CHECK_PROP(dummy,m_trans_blue_val ,!=); + //exact - when cast to EGLint is needed when comparing to EGL_DONT_CARE + CHECK_PROP_CAST(dummy,m_bind_to_tex_rgb ,!=); + CHECK_PROP_CAST(dummy,m_bind_to_tex_rgba,!=); + CHECK_PROP_CAST(dummy,m_caveat,!=); + CHECK_PROP_CAST(dummy,m_native_renderable ,!=); + CHECK_PROP_CAST(dummy,m_transparent_type ,!=); + + //mask + if(dummy.m_surface_type != EGL_DONT_CARE && + ((dummy.m_surface_type & m_surface_type) != dummy.m_surface_type)) return false; + + //passed all checks + return true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglConfig.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglConfig.h new file mode 100644 index 000000000..b47be12fe --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglConfig.h @@ -0,0 +1,95 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_CONFIG_H +#define EGL_CONFIG_H + +#include + +#define MIN_SWAP_INTERVAL 1 +#define MAX_SWAP_INTERVAL 10 + + +class EglConfig { +public: + bool getConfAttrib(EGLint attrib,EGLint* val) const; + bool operator<(const EglConfig& conf) const; + bool operator>=(const EglConfig& conf) const; + bool compitableWith(const EglConfig& conf) const; //compitability + bool choosen(const EglConfig& dummy); + EGLint surfaceType(){ return m_surface_type;}; + EGLint id(){return m_config_id;}; + EGLNativePixelFormatType nativeConfig(){ return m_nativeFormat;} + + EglConfig(EGLint red_size, + EGLint green_size, + EGLint blue_size, + EGLint alpha_size, + EGLenum caveat, + EGLint config_id, + EGLint depth_size, + EGLint frame_buffer_level, + EGLint max_pbuffer_width, + EGLint max_pbuffer_height, + EGLint max_pbuffer_size, + EGLBoolean native_renderable, + EGLint native_visual_id, + EGLint native_visual_type, + EGLint samples_per_pixel, + EGLint stencil_size, + EGLint surface_type, + EGLenum transparent_type, + EGLint trans_red_val, + EGLint trans_green_val, + EGLint trans_blue_val, + EGLNativePixelFormatType frmt = 0); + + EglConfig(const EglConfig& conf); + + +private: + + const EGLint m_buffer_size; + const EGLint m_red_size; + const EGLint m_green_size; + const EGLint m_blue_size; + const EGLint m_alpha_size; + const EGLBoolean m_bind_to_tex_rgb; + const EGLBoolean m_bind_to_tex_rgba; + const EGLenum m_caveat; + const EGLint m_config_id; + const EGLint m_frame_buffer_level; + const EGLint m_depth_size; + const EGLint m_max_pbuffer_width; + const EGLint m_max_pbuffer_height; + const EGLint m_max_pbuffer_size; + const EGLint m_max_swap_interval; + const EGLint m_min_swap_interval; + const EGLBoolean m_native_renderable; + const EGLint m_native_visual_id; + const EGLint m_native_visual_type; + const EGLint m_sample_buffers_num; + const EGLint m_samples_per_pixel; + const EGLint m_stencil_size; + const EGLint m_surface_type; + const EGLenum m_transparent_type; + const EGLint m_trans_red_val; + const EGLint m_trans_green_val; + const EGLint m_trans_blue_val; + + const EGLNativePixelFormatType m_nativeFormat; +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.cpp new file mode 100644 index 000000000..0190fdf06 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.cpp @@ -0,0 +1,55 @@ +/* +* Copyright (C) 2011 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 "EglContext.h" + +unsigned int EglContext::s_nextContextHndl = 0; + +bool EglContext::usingSurface(SurfacePtr surface) { + return surface.Ptr() == m_read.Ptr() || surface.Ptr() == m_draw.Ptr(); +} + +EglContext::EglContext(EGLNativeContextType context,ContextPtr shared_context, + EglConfig* config,GLEScontext* glesCtx,GLESVersion ver,ObjectNameManager* mngr): +m_native(context), +m_config(config), +m_glesContext(glesCtx), +m_read(NULL), +m_draw(NULL), +m_destroy(false), +m_version(ver) +{ + m_shareGroup = shared_context.Ptr()? + mngr->attachShareGroup(context,shared_context.Ptr()->getShareGroup().Ptr()): + mngr->createShareGroup(context); + m_hndl = ++s_nextContextHndl; +} + +void EglContext::setSurfaces(SurfacePtr read,SurfacePtr draw) +{ + m_read = read; + m_draw = draw; +} + +bool EglContext::getAttrib(EGLint attrib,EGLint* value) { + switch(attrib) { + case EGL_CONFIG_ID: + *value = m_config->id(); + break; + default: + return false; + } + return true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h new file mode 100644 index 000000000..f9445a1da --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglContext.h @@ -0,0 +1,71 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_CONTEXT_H +#define EGL_CONTEXT_H + +#include +#include +#include +#include +#include + + +#include "EglConfig.h" +#include "EglSurface.h" + + +typedef enum{ + GLES_1_1 = 0, + GLES_2_0 = 1, + MAX_GLES_VERSION //Must be last + }GLESVersion; + +class EglContext; +typedef SmartPtr ContextPtr; + +class EglContext { + +public: + + EglContext(EGLNativeContextType context,ContextPtr shared_context,EglConfig* config,GLEScontext* glesCtx,GLESVersion ver,ObjectNameManager* mngr); + bool usingSurface(SurfacePtr surface); + EGLNativeContextType nativeType(){return m_native;}; + void markForDestruction(){m_destroy = true;} + bool destroy(){ return m_destroy;} + bool getAttrib(EGLint attrib,EGLint* value); + SurfacePtr read(){ return m_read;}; + SurfacePtr draw(){ return m_draw;}; + ShareGroupPtr getShareGroup(){return m_shareGroup;} + EglConfig* getConfig(){ return m_config;}; + GLESVersion version(){return m_version;}; + GLEScontext* getGlesContext(){return m_glesContext;} + void setSurfaces(SurfacePtr read,SurfacePtr draw); + unsigned int getHndl(){return m_hndl;} + +private: + static unsigned int s_nextContextHndl; + EGLNativeContextType m_native; + EglConfig* m_config; + GLEScontext* m_glesContext; + ShareGroupPtr m_shareGroup; + SurfacePtr m_read; + SurfacePtr m_draw; + bool m_destroy; + GLESVersion m_version; + unsigned int m_hndl; +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglDisplay.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglDisplay.cpp new file mode 100644 index 000000000..9e174933e --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglDisplay.cpp @@ -0,0 +1,208 @@ +/* +* Copyright (C) 2011 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 "EglDisplay.h" +#include "EglOsApi.h" +#include +#include + +EglDisplay::EglDisplay(EGLNativeDisplayType dpy,bool isDefault):m_dpy(dpy),m_initialized(false),m_configInitialized(false),m_isDefault(isDefault){}; + +EglDisplay::~EglDisplay() { + android::Mutex::Autolock mutex(m_lock); + if(m_isDefault) { + EglOS::releaseDisplay(m_dpy); + } + + + for(ConfigsList::iterator it = m_configs.begin(); it != m_configs.end(); it++) { + EglConfig* pConfig = *it; + if(pConfig) delete pConfig; + } +} + +EGLNativeDisplayType EglDisplay::nativeType(){return m_dpy;} + +void EglDisplay::initialize() { + android::Mutex::Autolock mutex(m_lock); + m_initialized = true; + initConfigurations(); + m_configInitialized = true; +} + +bool EglDisplay::isInitialize() { return m_initialized;} + +void EglDisplay::terminate(){ + android::Mutex::Autolock mutex(m_lock); + m_contexts.clear(); + m_surfaces.clear(); + m_initialized = false; +} + +static bool compareEglConfigsPtrs(EglConfig* first,EglConfig* second) { + return *first < *second ; +} + +void EglDisplay::initConfigurations() { + if(m_configInitialized) return; + EglOS::queryConfigs(m_dpy,m_configs); + m_configs.sort(compareEglConfigsPtrs); +} + +EglConfig* EglDisplay::getConfig(EGLConfig conf) { + android::Mutex::Autolock mutex(m_lock); + + for(ConfigsList::iterator it = m_configs.begin(); it != m_configs.end() ;it++) { + if(static_cast(*it) == conf) { + return (*it); + + } + } + return NULL; +} + +SurfacePtr EglDisplay::getSurface(EGLSurface surface) { + android::Mutex::Autolock mutex(m_lock); + + SurfacesHndlMap::iterator it = m_surfaces.find(reinterpret_cast(surface)); + return it != m_surfaces.end() ? + (*it).second : + SurfacePtr(NULL); +} + +ContextPtr EglDisplay::getContext(EGLContext ctx) { + android::Mutex::Autolock mutex(m_lock); + + ContextsHndlMap::iterator it = m_contexts.find(reinterpret_cast(ctx)); + return it != m_contexts.end() ? + (*it).second : + ContextPtr(NULL); +} + +bool EglDisplay::removeSurface(EGLSurface s) { + android::Mutex::Autolock mutex(m_lock); + + SurfacesHndlMap::iterator it = m_surfaces.find(reinterpret_cast(s)); + if(it != m_surfaces.end()) { + m_surfaces.erase(it); + return true; + } + return false; +} + +bool EglDisplay::removeSurface(SurfacePtr s) { + android::Mutex::Autolock mutex(m_lock); + + SurfacesHndlMap::iterator it; + for(it = m_surfaces.begin(); it!= m_surfaces.end();it++) + { + if((*it).second == s.Ptr()) { + break; + } + } + if(it != m_surfaces.end()) { + m_surfaces.erase(it); + return true; + } + return false; +} + +bool EglDisplay::removeContext(EGLContext ctx) { + android::Mutex::Autolock mutex(m_lock); + + ContextsHndlMap::iterator it = m_contexts.find(reinterpret_cast(ctx)); + if(it != m_contexts.end()) { + m_contexts.erase(it); + return true; + } + return false; +} + +bool EglDisplay::removeContext(ContextPtr ctx) { + android::Mutex::Autolock mutex(m_lock); + + ContextsHndlMap::iterator it; + for(it = m_contexts.begin(); it != m_contexts.end();it++) { + if((*it).second == ctx.Ptr()){ + break; + } + } + if(it != m_contexts.end()) { + m_contexts.erase(it); + return true; + } + return false; +} + +EglConfig* EglDisplay::getConfig(EGLint id) { + android::Mutex::Autolock mutex(m_lock); + + for(ConfigsList::iterator it = m_configs.begin(); it != m_configs.end() ;it++) { + if((*it)->id() == id) { + return (*it); + + } + } + return NULL; +} + +int EglDisplay::getConfigs(EGLConfig* configs,int config_size) { + android::Mutex::Autolock mutex(m_lock); + int i = 0; + for(ConfigsList::iterator it = m_configs.begin(); it != m_configs.end() && i < config_size ;i++,it++) { + configs[i] = static_cast(*it); + } + return i; +} + +int EglDisplay::chooseConfigs(const EglConfig& dummy,EGLConfig* configs,int config_size) { + android::Mutex::Autolock mutex(m_lock); + int added = 0; + for(ConfigsList::iterator it = m_configs.begin(); it != m_configs.end() && added < config_size;it++) { + + if( (*it)->choosen(dummy)){ + configs[added++] = static_cast(*it); + } + } + //no need to sort since the configurations are saved already in sorted maner + return added; +} + +EGLSurface EglDisplay::addSurface(SurfacePtr s ) { + android::Mutex::Autolock mutex(m_lock); + unsigned int hndl = s.Ptr()->getHndl(); + EGLSurface ret =reinterpret_cast (hndl); + + if(m_surfaces.find(hndl) != m_surfaces.end()) { + return ret; + } + + m_surfaces[hndl] = s; + return ret; +} + +EGLContext EglDisplay::addContext(ContextPtr ctx ) { + android::Mutex::Autolock mutex(m_lock); + + unsigned int hndl = ctx.Ptr()->getHndl(); + EGLContext ret = reinterpret_cast (hndl); + + if(m_contexts.find(hndl) != m_contexts.end()) { + return ret; + } + + m_contexts[hndl] = ctx; + return ret; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglDisplay.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglDisplay.h new file mode 100644 index 000000000..9c04cf980 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglDisplay.h @@ -0,0 +1,79 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_DISPLAY_H +#define EGL_DISPLAY_H + +#include +#include +#include +#include +#include + +#include "EglConfig.h" +#include "EglContext.h" +#include "EglSurface.h" +#include "EglWindowSurface.h" + + + +typedef std::list ConfigsList; +typedef std::map< unsigned int,ContextPtr > ContextsHndlMap; +typedef std::map< unsigned int,SurfacePtr > SurfacesHndlMap; + +class EglDisplay { +public: + + + EglDisplay(EGLNativeDisplayType dpy,bool isDefault = true); + EGLNativeDisplayType nativeType(); + int nConfigs(){ return m_configs.size();} + int getConfigs(EGLConfig* configs,int config_size); + int chooseConfigs(const EglConfig& dummy,EGLConfig* configs,int config_size); + EglConfig* getConfig(EGLConfig conf); + EglConfig* getConfig(EGLint id ); + + EGLSurface addSurface(SurfacePtr s ); + SurfacePtr getSurface(EGLSurface surface); + bool removeSurface(EGLSurface s); + bool removeSurface(SurfacePtr s); + + EGLContext addContext(ContextPtr ctx ); + ContextPtr getContext(EGLContext ctx); + bool removeContext(EGLContext ctx); + bool removeContext(ContextPtr ctx); + ObjectNameManager* getManager(GLESVersion ver){ return &m_manager[ver];} + + ~EglDisplay(); + void initialize(); + void terminate(); + bool isInitialize(); +private: + void initConfigurations(); + + EGLNativeDisplayType m_dpy; + bool m_initialized; + bool m_configInitialized; + bool m_isDefault; + ConfigsList m_configs; + ContextsHndlMap m_contexts; + SurfacesHndlMap m_surfaces; + ObjectNameManager m_manager[MAX_GLES_VERSION]; + android::Mutex m_lock; +}; + +#endif + + diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglGlobalInfo.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglGlobalInfo.cpp new file mode 100644 index 000000000..23cf52aa4 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglGlobalInfo.cpp @@ -0,0 +1,89 @@ +/* +* Copyright (C) 2011 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 "EglGlobalInfo.h" +#include "EglOsApi.h" +#include + +int EglGlobalInfo::m_refCount = 0; +EglGlobalInfo* EglGlobalInfo::m_singleton = NULL; + + +EglGlobalInfo::EglGlobalInfo(){ + m_default = EglOS::getDefaultDisplay(); + memset(m_gles_ifaces,0,sizeof(m_gles_ifaces)); +} + +EglGlobalInfo* EglGlobalInfo::getInstance() { + if(!m_singleton) { + m_singleton = new EglGlobalInfo(); + m_refCount = 0; + } + m_refCount++; + return m_singleton; +} + +void EglGlobalInfo::delInstance() { + m_refCount--; + if(m_refCount <= 0 && m_singleton) { + delete m_singleton; + m_singleton = NULL; + } + +} + +EglDisplay* EglGlobalInfo::addDisplay(EGLNativeDisplayType dpy) { + //search if it is not already exists + android::Mutex::Autolock mutex(m_lock); + for(DisplaysList::iterator it = m_displays.begin(); it != m_displays.end() ;it++) { + if((*it)->nativeType() == dpy) return (*it); + } + + EglDisplay* p_dpy = new EglDisplay(dpy); + if(p_dpy) { + m_displays.push_front(p_dpy); + return p_dpy; + } + return NULL; +} + +bool EglGlobalInfo::removeDisplay(EGLDisplay dpy) { + + android::Mutex::Autolock mutex(m_lock); + for(DisplaysList::iterator it = m_displays.begin(); it != m_displays.end() ;it++) { + if(static_cast(*it) == dpy) { + delete (*it); + m_displays.remove(*it); + return true; + } + } + return false; +} + +EglDisplay* EglGlobalInfo::getDisplay(EGLNativeDisplayType dpy) { + android::Mutex::Autolock mutex(m_lock); + for(DisplaysList::iterator it = m_displays.begin(); it != m_displays.end() ;it++) { + if((*it)->nativeType() == dpy) return (*it); + } + return NULL; +} + +EglDisplay* EglGlobalInfo::getDisplay(EGLDisplay dpy) { + android::Mutex::Autolock mutex(m_lock); + for(DisplaysList::iterator it = m_displays.begin(); it != m_displays.end() ;it++) { + if(static_cast(*it) == dpy) return (*it); + } + return NULL; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglGlobalInfo.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglGlobalInfo.h new file mode 100644 index 000000000..5e03e72d7 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglGlobalInfo.h @@ -0,0 +1,61 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_GLOBAL_INFO +#define EGL_GLOBAL_INFO + +#include +#include +#include +#include +#include "EglDisplay.h" +#include "EglConfig.h" +#include "EglContext.h" + +typedef std::list DisplaysList; + + +class EglGlobalInfo { + +public: + EglDisplay* addDisplay(EGLNativeDisplayType dpy); + EglDisplay* getDisplay(EGLNativeDisplayType dpy); + EglDisplay* getDisplay(EGLDisplay dpy); + bool removeDisplay(EGLDisplay dpy); + EGLNativeDisplayType getDefaultNativeDisplay(){ return m_default;}; + + void setIface(GLESiface* iface,GLESVersion ver) { m_gles_ifaces[ver] = iface;}; + GLESiface* getIface(GLESVersion ver){ return m_gles_ifaces[ver];} + + + int nDisplays() const { return m_displays.size();}; + + static EglGlobalInfo* getInstance(); + static void delInstance(); + +private: + EglGlobalInfo(); + ~EglGlobalInfo(){}; + + static EglGlobalInfo* m_singleton; + static int m_refCount; + + DisplaysList m_displays; + EGLNativeDisplayType m_default; + GLESiface* m_gles_ifaces[MAX_GLES_VERSION]; + android::Mutex m_lock; +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp new file mode 100644 index 000000000..893181164 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglImp.cpp @@ -0,0 +1,916 @@ +/* +* Copyright (C) 2011 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 +#include +#include +#include +#include +#include + +#include "EglWindowSurface.h" +#include "EglPbufferSurface.h" +#include "EglPixmapSurface.h" +#include "EglGlobalInfo.h" +#include "EglThreadInfo.h" +#include "EglValidate.h" +#include "EglDisplay.h" +#include "EglContext.h" +#include "EglConfig.h" +#include "EglOsApi.h" + +#define MINOR 1 +#define MAJOR 4 + +EglGlobalInfo* g_eglInfo = EglGlobalInfo::getInstance(); + +__thread EglThreadInfo* tls_thread = NULL; +static EGLiface s_eglIface = { + getThreadInfo: getThreadInfo // implemented in ThreadInfo.cpp +}; + +//extentions +typedef struct { + const char* name; + __eglMustCastToProperFunctionPointerType address; +} EglExtentionDescriptor; + +#define EGL_EXTENTIONS 0 +//supported extentions; +static EglExtentionDescriptor s_extentions[] = {}; + +//macros for accessing global egl info & tls objects + +#define CURRENT_THREAD() \ + if(!tls_thread) { \ + tls_thread = new EglThreadInfo(); \ + } + +#define RETURN_ERROR(ret,err) \ + CURRENT_THREAD() \ + if(tls_thread->getError() == EGL_SUCCESS) { \ + tls_thread->setError(err); \ + } \ + return ret; + +#define VALIDATE_DISPLAY_RETURN(EGLDisplay,ret) \ + EglDisplay* dpy = g_eglInfo->getDisplay(EGLDisplay); \ + if(!dpy){ \ + RETURN_ERROR(ret,EGL_BAD_DISPLAY); \ + } \ + if(!dpy->isInitialize()) { \ + RETURN_ERROR(ret,EGL_NOT_INITIALIZED); \ + } + +#define VALIDATE_CONFIG_RETURN(EGLConfig,ret) \ + EglConfig* cfg = dpy->getConfig(EGLConfig); \ + if(!cfg) { \ + RETURN_ERROR(ret,EGL_BAD_CONFIG); \ + } + +#define VALIDATE_SURFACE_RETURN(EGLSurface,ret,varName) \ + SurfacePtr varName = dpy->getSurface(EGLSurface); \ + if(!varName.Ptr()) { \ + RETURN_ERROR(ret,EGL_BAD_SURFACE); \ + } + +#define VALIDATE_CONTEXT_RETURN(EGLContext,ret) \ + ContextPtr ctx = dpy->getContext(EGLContext); \ + if(!ctx.Ptr()) { \ + RETURN_ERROR(ret,EGL_BAD_CONTEXT); \ + } + +#define VALIDATE_DISPLAY(EGLDisplay) \ + VALIDATE_DISPLAY_RETURN(EGLDisplay,EGL_FALSE) + +#define VALIDATE_CONFIG(EGLConfig) \ + VALIDATE_CONFIG_RETURN(EGLConfig,EGL_FALSE) + +#define VALIDATE_SURFACE(EGLSurface,varName) \ + VALIDATE_SURFACE_RETURN(EGLSurface,EGL_FALSE,varName) + +#define VALIDATE_CONTEXT(EGLContext) \ + VALIDATE_CONTEXT_RETURN(EGLContext,EGL_FALSE) + +EGLAPI EGLint EGLAPIENTRY eglGetError(void) { + CURRENT_THREAD(); + EGLint err = tls_thread->getError(); + tls_thread->setError(EGL_SUCCESS); + return err; +} + +EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id) { + EglDisplay* dpy = NULL; + + if( display_id == EGL_DEFAULT_DISPLAY) { + display_id = g_eglInfo->getDefaultNativeDisplay(); + } + + if ((dpy = g_eglInfo->getDisplay(display_id))) { + return dpy; + } else { + dpy = g_eglInfo->addDisplay(display_id); + if(dpy) return dpy; + return EGL_NO_DISPLAY; + } +} + + +static __translator_getGLESIfaceFunc loadIfaces(const char* libName){ + void* libGLES = dlopen(libName, RTLD_NOW); + if(!libGLES) return NULL; + __translator_getGLESIfaceFunc func = (__translator_getGLESIfaceFunc)dlsym(libGLES,"__translator_getIfaces"); + if(!func) return NULL; + return func; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay display, EGLint *major, EGLint *minor) { + EglDisplay* dpy = g_eglInfo->getDisplay(display); + if(!dpy) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_DISPLAY); + } + + if(major) *major = MAJOR; + if(minor) *minor = MINOR; + + if(!g_eglInfo->getIface(GLES_1_1)) { + __translator_getGLESIfaceFunc func = loadIfaces("libGLES_CM_translator.so"); + if(func){ + g_eglInfo->setIface(func(&s_eglIface),GLES_1_1); + } else { + return EGL_FALSE; + } + } + dpy->initialize(); + return EGL_TRUE; +} + +//TODO check this func definitions later on +EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay display) { + VALIDATE_DISPLAY(display); + dpy->terminate(); + return EGL_TRUE; +} + +EGLAPI const char * EGLAPIENTRY eglQueryString(EGLDisplay display, EGLint name) { + VALIDATE_DISPLAY(display); + static const char* vendor = "Google"; + static const char* version = "1.4"; + static const char* extensions = "EGL_KHR_image_base EGL_KHR_gl_texture_2d_image"; //XXX: Not implemented yet + if(!EglValidate::stringName(name)) { + RETURN_ERROR(NULL,EGL_BAD_PARAMETER); + } + switch(name) { + case EGL_VENDOR: + return vendor; + case EGL_VERSION: + return version; + case EGL_EXTENSIONS: + return extensions; + } + return NULL; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay display, EGLConfig *configs, + EGLint config_size, EGLint *num_config) { + VALIDATE_DISPLAY(display); + if(!num_config) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); + } + + if(configs == NULL) { + *num_config = dpy->nConfigs(); + } else { + *num_config = dpy->getConfigs(configs,config_size); + } + + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay display, const EGLint *attrib_list, + EGLConfig *configs, EGLint config_size, + EGLint *num_config) { + VALIDATE_DISPLAY(display); + if(!num_config) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); + } + + //selection defaults + EGLint surface_type = EGL_WINDOW_BIT; + EGLBoolean bind_to_tex_rgb = EGL_DONT_CARE; + EGLBoolean bind_to_tex_rgba = EGL_DONT_CARE; + EGLenum caveat = EGL_DONT_CARE; + EGLint config_id = EGL_DONT_CARE; + EGLBoolean native_renderable = EGL_DONT_CARE; + EGLint native_visual_type = EGL_DONT_CARE; + EGLint max_swap_interval = EGL_DONT_CARE; + EGLint min_swap_interval = EGL_DONT_CARE; + EGLint trans_red_val = EGL_DONT_CARE; + EGLint trans_green_val = EGL_DONT_CARE; + EGLint trans_blue_val = EGL_DONT_CARE; + EGLenum transparent_type = EGL_NONE; + EGLint buffer_size = 0; + EGLint red_size = 0; + EGLint green_size = 0; + EGLint blue_size = 0; + EGLint alpha_size = 0; + EGLint depth_size = 0; + EGLint frame_buffer_level = 0; + EGLint sample_buffers_num = 0; + EGLint samples_per_pixel = 0; + EGLint stencil_size = 0; + + if(!EglValidate::noAttribs(attrib_list)) { //there are attribs + int i = 0 ; + bool hasConfigId = false; + while(attrib_list[i] != EGL_NONE && !hasConfigId) { + switch(attrib_list[i]) { + case EGL_MAX_PBUFFER_WIDTH: + case EGL_MAX_PBUFFER_HEIGHT: + case EGL_MAX_PBUFFER_PIXELS: + case EGL_NATIVE_VISUAL_ID: + continue; //we dont care from those selection crateria + case EGL_LEVEL: + if(attrib_list[i+1] == EGL_DONT_CARE) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + frame_buffer_level = attrib_list[i+1]; + break; + case EGL_BUFFER_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + buffer_size = attrib_list[i+1]; + break; + case EGL_RED_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + red_size = attrib_list[i+1]; + break; + case EGL_GREEN_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + green_size = attrib_list[i+1]; + break; + case EGL_BLUE_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + blue_size = attrib_list[i+1]; + break; + case EGL_ALPHA_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + alpha_size = attrib_list[i+1]; + break; + case EGL_BIND_TO_TEXTURE_RGB: + bind_to_tex_rgb = attrib_list[i+1]; + break; + case EGL_BIND_TO_TEXTURE_RGBA: + bind_to_tex_rgba = attrib_list[i+1]; + break; + case EGL_CONFIG_CAVEAT: + if(attrib_list[i+1] != EGL_NONE && attrib_list[i+1] != EGL_SLOW_CONFIG && attrib_list[i+1] != EGL_NON_CONFORMANT_CONFIG) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + caveat = attrib_list[i+1]; + break; + case EGL_CONFIG_ID: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + config_id = attrib_list[i+1]; + hasConfigId = true; + break; + case EGL_DEPTH_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + depth_size = attrib_list[i+1]; + break; + case EGL_MAX_SWAP_INTERVAL: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + max_swap_interval = attrib_list[i+1]; + break; + case EGL_MIN_SWAP_INTERVAL: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + min_swap_interval = attrib_list[i+1]; + break; + case EGL_NATIVE_RENDERABLE: + native_renderable = attrib_list[i+1]; + break; + case EGL_NATIVE_VISUAL_TYPE: + native_visual_type = attrib_list[i+1]; + break; + if(attrib_list[i+1] < 0 || attrib_list[i+1] > 1 ) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + case EGL_SAMPLE_BUFFERS: + sample_buffers_num = attrib_list[i+1]; + break; + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + case EGL_SAMPLES: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + samples_per_pixel = attrib_list[i+1]; + break; + case EGL_STENCIL_SIZE: + if(attrib_list[i+1] < 0) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + stencil_size = attrib_list[i+1]; + break; + case EGL_SURFACE_TYPE: + surface_type = attrib_list[i+1]; + break; + case EGL_TRANSPARENT_TYPE: + if(attrib_list[i+1] != EGL_NONE && attrib_list[i+1] != EGL_TRANSPARENT_RGB ) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + transparent_type = attrib_list[i+1]; + break; + case EGL_TRANSPARENT_RED_VALUE: + trans_red_val = attrib_list[i+1]; + break; + case EGL_TRANSPARENT_GREEN_VALUE: + trans_green_val = attrib_list[i+1]; + break; + case EGL_TRANSPARENT_BLUE_VALUE: + trans_blue_val = attrib_list[i+1]; + break; + default: + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + i+=2; + } + if(hasConfigId) { + EglConfig* pConfig = dpy->getConfig(config_id); + if(pConfig) { + configs[0] = static_cast(pConfig); + *num_config = 0; + return EGL_TRUE; + } else { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + } + } + EglConfig dummy(red_size,green_size,blue_size,alpha_size,caveat,config_id,depth_size, + frame_buffer_level,0,0,0,native_renderable,0,native_visual_type, + samples_per_pixel,stencil_size,surface_type,transparent_type, + trans_red_val,trans_green_val,trans_blue_val); + *num_config = dpy->chooseConfigs(dummy,configs,config_size); + + + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay display, EGLConfig config, + EGLint attribute, EGLint *value) { + VALIDATE_DISPLAY(display); + VALIDATE_CONFIG(config); + if(!EglValidate::confAttrib(attribute)){ + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + return cfg->getConfAttrib(attribute,value)? EGL_TRUE:EGL_FALSE; +} + +EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay display, EGLConfig config, + EGLNativeWindowType win, + const EGLint *attrib_list) { + VALIDATE_DISPLAY_RETURN(display,EGL_NO_SURFACE); + VALIDATE_CONFIG_RETURN(config,EGL_NO_SURFACE); + + if(!(cfg->surfaceType() & EGL_WINDOW_BIT)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_MATCH); + } + if(!EglOS::validNativeWin(win)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_NATIVE_WINDOW); + } + if(!EglValidate::noAttribs(attrib_list)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); + } + if(EglWindowSurface::alreadyAssociatedWithConfig(win)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + + unsigned int width,height; + if(!EglOS::checkWindowPixelFormatMatch(dpy->nativeType(),win,cfg,&width,&height)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + SurfacePtr wSurface(new EglWindowSurface(win,cfg,width,height)); + if(!wSurface.Ptr()) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + return dpy->addSurface(wSurface); +} + +EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay display, EGLConfig config, + const EGLint *attrib_list) { + VALIDATE_DISPLAY_RETURN(display,EGL_NO_SURFACE); + VALIDATE_CONFIG_RETURN(config,EGL_NO_SURFACE); + if(!(cfg->surfaceType() & EGL_PBUFFER_BIT)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_MATCH); + } + + + SurfacePtr pbSurface(new EglPbufferSurface(cfg)); + if(!pbSurface.Ptr()) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + + if(!EglValidate::noAttribs(attrib_list)) { //there are attribs + int i = 0 ; + while(attrib_list[i] != EGL_NONE) { + if(!pbSurface.Ptr()->setAttrib(attrib_list[i],attrib_list[i+1])) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); + } + i+=2; + } + } + + EGLint width,height,largest,texTarget,texFormat; + EglPbufferSurface* tmpPbSurfacePtr = static_cast(pbSurface.Ptr()); + tmpPbSurfacePtr->getDim(&width,&height,&largest); + tmpPbSurfacePtr->getTexInfo(&texTarget,&texFormat); + + if(!EglValidate::pbufferAttribs(width,height,texFormat == EGL_NO_TEXTURE,texTarget == EGL_NO_TEXTURE)) { + //TODO: RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_VALUE); dont have bad_value + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); + } + + EGLNativePbufferType pb = EglOS::createPbuffer(dpy->nativeType(),cfg,tmpPbSurfacePtr); + if(!pb) { + //TODO: RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_VALUE); dont have bad value + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); + } + + tmpPbSurfacePtr->setNativePbuffer(pb); + return dpy->addSurface(pbSurface); +} + +EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay display, EGLConfig config, + EGLNativePixmapType pixmap, + const EGLint *attrib_list) { + VALIDATE_DISPLAY_RETURN(display,EGL_NO_SURFACE); + VALIDATE_CONFIG_RETURN(config,EGL_NO_SURFACE); + if(!(cfg->surfaceType() & EGL_PIXMAP_BIT)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_MATCH); + } + if(!EglValidate::noAttribs(attrib_list)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ATTRIBUTE); + } + if(EglPixmapSurface::alreadyAssociatedWithConfig(pixmap)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + + unsigned int width,height; + if(!EglOS::checkPixmapPixelFormatMatch(dpy->nativeType(),pixmap,cfg,&width,&height)) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + SurfacePtr pixSurface(new EglPixmapSurface(pixmap,cfg)); + if(!pixSurface.Ptr()) { + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_ALLOC); + } + + return dpy->addSurface(pixSurface); +} + +static bool destroySurfaceIfNotCurrent(EglDisplay* dpy,SurfacePtr surface) { + + ThreadInfo* thread = getThreadInfo(); + EglContext* currCtx = static_cast(thread->eglContext); + if(currCtx && !currCtx->usingSurface(surface)){ + if(surface.Ptr()->type() == EglSurface::PBUFFER) { + EglOS::releasePbuffer(dpy->nativeType(),reinterpret_cast(surface.Ptr()->native())); + return true; + } + } + return false; +} +EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay display, EGLSurface surface) { + VALIDATE_DISPLAY(display); + SurfacePtr srfc = dpy->getSurface(surface); + if(!srfc.Ptr()) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + + srfc.Ptr()->destroy(); //mark surface for destruction + if(destroySurfaceIfNotCurrent(dpy,srfc)) { //removes surface from the list if not current + dpy->removeSurface(surface); + } + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay display, EGLSurface surface, + EGLint attribute, EGLint *value) { + VALIDATE_DISPLAY(display); + VALIDATE_SURFACE(surface,srfc); + + if(!srfc.Ptr()->getAttrib(attribute,value)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay display, EGLSurface surface, + EGLint attribute, EGLint value) { + VALIDATE_DISPLAY(display); + VALIDATE_SURFACE(surface,srfc); + if(!srfc.Ptr()->setAttrib(attribute,value)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + return EGL_TRUE; +} + +EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay display, EGLConfig config, + EGLContext share_context, + const EGLint *attrib_list) { + VALIDATE_DISPLAY_RETURN(display,EGL_NO_CONTEXT); + VALIDATE_CONFIG_RETURN(config,EGL_NO_CONTEXT); + + GLESVersion version = GLES_1_1; + if(!EglValidate::noAttribs(attrib_list)) { + int i = 0; + while(attrib_list[i] != EGL_NONE) { + switch(attrib_list[i]) { + case EGL_CONTEXT_CLIENT_VERSION: + if(attrib_list[i+1] == 2) { + version = GLES_2_0; + } else { + version = GLES_1_1; + } + break; + default: + RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_ATTRIBUTE); + } + i+=2; + } + } + GLESiface* iface = g_eglInfo->getIface(version); + GLEScontext* glesCtx = NULL; + if(iface) { + glesCtx = iface->createGLESContext(); + } else { // there is no interface for this gles version + RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_ATTRIBUTE); + } + + ContextPtr sharedCtxPtr; + EGLNativeContextType nativeShared = NULL; + if(share_context != EGL_NO_CONTEXT) { + sharedCtxPtr = dpy->getContext(share_context); + if(!sharedCtxPtr.Ptr()) { + RETURN_ERROR(EGL_NO_CONTEXT,EGL_BAD_CONTEXT); + } + nativeShared = sharedCtxPtr->nativeType(); + } + + EGLNativeContextType nativeContext = EglOS::createContext(dpy->nativeType(),cfg,nativeShared); + if(nativeContext) { + ContextPtr ctx(new EglContext(nativeContext,sharedCtxPtr,cfg,glesCtx,version,dpy->getManager(version))); + return dpy->addContext(ctx); + } else { + iface->deleteGLESContext(glesCtx); + } + + +return EGL_NO_CONTEXT; +} + +static bool destroyContextIfNotCurrent(EglDisplay* dpy,ContextPtr ctx ) { + ThreadInfo* thread = getThreadInfo(); + EglContext* currCtx = static_cast(thread->eglContext); + if(ctx.Ptr() != currCtx ){ + EglOS::destroyContext(dpy->nativeType(),ctx.Ptr()->nativeType()); + return true; + } + return false; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay display, EGLContext context) { + VALIDATE_DISPLAY(display); + VALIDATE_CONTEXT(context); + + ctx.Ptr()->destroy(); //mark for destruction + if(destroyContextIfNotCurrent(dpy,ctx)){ //removes the context from the list if it is not current + g_eglInfo->getIface(ctx.Ptr()->version())->deleteGLESContext(ctx.Ptr()->getGlesContext()); + dpy->removeContext(context); + } + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay display, EGLSurface draw, + EGLSurface read, EGLContext context) { + VALIDATE_DISPLAY(display); + + bool releaseContext = EglValidate::releaseContext(context,read,draw); + if(!releaseContext && EglValidate::badContextMatch(context,read,draw)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_MATCH); + } + + VALIDATE_CONTEXT(context); + VALIDATE_SURFACE(draw,newDrawSrfc); + VALIDATE_SURFACE(read,newReadSrfc); + + EglSurface* newDrawPtr = newDrawSrfc.Ptr(); + EglSurface* newReadPtr = newReadSrfc.Ptr(); + EglContext* newCtx = ctx.Ptr(); + ThreadInfo* thread = getThreadInfo(); + EglContext* prevCtx = static_cast(thread->eglContext); + + if(releaseContext) { //releasing current context + if(prevCtx) { + g_eglInfo->getIface(prevCtx->version())->flush(); + if(!EglOS::makeCurrent(dpy->nativeType(),NULL,NULL,NULL)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ACCESS); + } + thread->updateInfo(newCtx,dpy,NULL,newCtx->getShareGroup(),dpy->getManager(newCtx->version())); + ctx.Ptr()->setSurfaces(SurfacePtr(NULL),SurfacePtr(NULL)); + } + } else { //assining new context + //surfaces compitability check + if(!((*ctx->getConfig()).compitableWith((*newDrawPtr->getConfig()))) || + !((*ctx->getConfig()).compitableWith((*newReadPtr->getConfig())))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_MATCH); + } + + //checking native window validity + if(newReadPtr->type() == EglSurface::WINDOW && !EglOS::validNativeWin(reinterpret_cast(newReadPtr->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_WINDOW); + } + if(newDrawPtr->type() == EglSurface::WINDOW && !EglOS::validNativeWin(reinterpret_cast(newDrawPtr->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_WINDOW); + } + + //checking native pixmap validity + if(newReadPtr->type() == EglSurface::PIXMAP && !EglOS::validNativePixmap(reinterpret_cast(newReadPtr->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); + } + if(newDrawPtr->type() == EglSurface::PIXMAP && !EglOS::validNativePixmap(reinterpret_cast(newDrawPtr->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); + } + if(prevCtx) { + g_eglInfo->getIface(prevCtx->version())->flush(); + } + if(!EglOS::makeCurrent(dpy->nativeType(),newReadPtr,newDrawPtr,newCtx->nativeType())) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_ACCESS); + } + //TODO: handle the following errors + // EGL_BAD_CURRENT_SURFACE , EGL_CONTEXT_LOST , EGL_BAD_ACCESS + + thread->updateInfo(newCtx,dpy,newCtx->getGlesContext(),newCtx->getShareGroup(),dpy->getManager(newCtx->version())); + newCtx->setSurfaces(newReadSrfc,newDrawSrfc); + g_eglInfo->getIface(newCtx->version())->initContext(newCtx->getGlesContext()); + } + + SurfacePtr prevRead; + SurfacePtr prevDraw; + //removing terminated surfaces & context + if(prevCtx) { + prevRead = prevCtx->read(); + if(prevRead.Ptr()->destroy()){ + if(destroySurfaceIfNotCurrent(dpy,prevRead)) { //removes surface from the list if not current + dpy->removeSurface(prevRead); + } + } + prevDraw = prevCtx->draw(); + if(prevDraw.Ptr()->destroy()){ + if(destroySurfaceIfNotCurrent(dpy,prevDraw)) { //removes surface from the list if not current + dpy->removeSurface(prevDraw); + } + } + + if(prevCtx->destroy()) { + ContextPtr prevCtxPtr = ContextPtr(prevCtx); + if(destroyContextIfNotCurrent(dpy,prevCtxPtr)){ //removes the context from the list if it is not current + g_eglInfo->getIface(prevCtx->version())->deleteGLESContext(prevCtx->getGlesContext()); + dpy->removeContext(prevCtxPtr); + } + } + } + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay display, EGLContext context, + EGLint attribute, EGLint *value) { + VALIDATE_DISPLAY(display); + VALIDATE_CONTEXT(context); + + if(!ctx->getAttrib(attribute,value)){ + RETURN_ERROR(EGL_FALSE,EGL_BAD_ATTRIBUTE); + } + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay display, EGLSurface surface) { + VALIDATE_DISPLAY(display); + VALIDATE_SURFACE(surface,Srfc); + ThreadInfo* thread = getThreadInfo(); + EglContext* currentCtx = static_cast(thread->eglContext); + + + //if surface not window return + if(Srfc.Ptr()->type() != EglSurface::WINDOW){ + RETURN_ERROR(EGL_TRUE,EGL_SUCCESS); + } + + if(!currentCtx || !currentCtx->usingSurface(Srfc) || !EglOS::validNativeWin(reinterpret_cast(Srfc.Ptr()->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + + EglOS::swapBuffers(dpy->nativeType(),reinterpret_cast(Srfc.Ptr()->native())); + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay display, EGLint interval) { + VALIDATE_DISPLAY(display); + ThreadInfo* thread = getThreadInfo(); + EglContext* currCtx = static_cast(thread->eglContext); + if(currCtx) { + if(!currCtx->read().Ptr() || !currCtx->draw().Ptr() || currCtx->draw().Ptr()->type()!=EglSurface::WINDOW) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_CURRENT_SURFACE); + } + EglOS::swapInterval(dpy->nativeType(),reinterpret_cast(currCtx->draw().Ptr()->native()),interval); + } else { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + return EGL_TRUE; +} + + +EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void) { + ThreadInfo* thread = getThreadInfo(); + EglDisplay* dpy = static_cast(thread->eglDisplay); + EglContext* ctx = static_cast(thread->eglContext); + if(dpy && ctx){ + return dpy->getContext(ContextPtr(ctx)); + } + return EGL_NO_CONTEXT; +} + +EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw) { + if(!EglValidate::surfaceTarget(readdraw)) return EGL_NO_SURFACE; + + ThreadInfo* thread = getThreadInfo(); + EglDisplay* dpy = static_cast(thread->eglDisplay); + EglContext* ctx = static_cast(thread->eglContext); + + if(dpy && ctx) { + SurfacePtr surface = readdraw == EGL_READ ? ctx->read() : ctx->draw(); + return dpy->getSurface(surface); + } + return EGL_NO_SURFACE; +} + +EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void) { + ThreadInfo* thread = getThreadInfo(); + return (thread->eglContext) ? thread->eglDisplay : EGL_NO_DISPLAY; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void) { + EGLenum api = eglQueryAPI(); + eglBindAPI(EGL_OPENGL_ES_API); + return eglWaitClient(); +} + +EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine) { + if(!EglValidate::engine(engine)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); + } + ThreadInfo* thread = getThreadInfo(); + EglContext* currCtx = static_cast(thread->eglContext); + if(currCtx) { + EglSurface* read = currCtx->read().Ptr(); + EglSurface* draw = currCtx->read().Ptr(); + + if(read) { + if(read->type() == EglSurface::WINDOW && + !EglOS::validNativeWin(reinterpret_cast(read->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + if(read->type() == EglSurface::PIXMAP && + !EglOS::validNativePixmap(reinterpret_cast(read->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + } + if(draw) { + if(draw->type() == EglSurface::WINDOW && + !EglOS::validNativeWin(reinterpret_cast(draw->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + if(draw->type() == EglSurface::PIXMAP && + !EglOS::validNativePixmap(reinterpret_cast(draw->native()))) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_SURFACE); + } + } + } + EglOS::waitNative(); + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api) { + if(!EglValidate::supportedApi(api)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER); + } + CURRENT_THREAD(); + tls_thread->setApi(api); + return EGL_TRUE; +} + +EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void) { + CURRENT_THREAD(); + return tls_thread->getApi(); +} + +EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void) { + ThreadInfo* thread = getThreadInfo(); + EglContext* currCtx = static_cast(thread->eglContext); + if(currCtx) { + if(!currCtx->read().Ptr() || !currCtx->draw().Ptr()) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_CURRENT_SURFACE); + } + g_eglInfo->getIface(currCtx->version())->finish(); + } + return EGL_TRUE; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void) { + ThreadInfo* thread = getThreadInfo(); + EglDisplay* dpy = static_cast(thread->eglDisplay); + return eglMakeCurrent(dpy,EGL_NO_SURFACE,EGL_NO_SURFACE,EGL_NO_CONTEXT); +} + +EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY + eglGetProcAddress(const char *procname){ + if(!strncmp(procname,"egl",3)) { //EGL proc + for(int i=0;i < EGL_EXTENSIONS;i++){ + if(strcmp(procname,s_extentions[i].name) == 0){ + return s_extentions[i].address; + } + } + } else if (!strncmp(procname,"gl",2)){ //GL proc + //TODO:call glGetProcAdress + } + return NULL; +} +//not supported for now +/************************* NOT SUPPORTED FOR NOW ***********************/ +EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer( + EGLDisplay display, EGLenum buftype, EGLClientBuffer buffer, + EGLConfig config, const EGLint *attrib_list) { + VALIDATE_DISPLAY(display); + VALIDATE_CONFIG(config); + //we do not support for now openVG, and the only client API resources which may be bound in this fashion are OpenVG + RETURN_ERROR(EGL_NO_SURFACE,EGL_BAD_PARAMETER); +} + +EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay display, EGLSurface surface, + EGLNativePixmapType target) { + VALIDATE_DISPLAY(display); + VALIDATE_SURFACE(surface,srfc); + if(!EglOS::validNativePixmap(target)) { + RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); + } + + //we do not need to support this for android , since we are not gonna use pixmaps + RETURN_ERROR(EGL_FALSE,EGL_BAD_NATIVE_PIXMAP); +} + +/***********************************************************************/ + + +//do last ( only if needed) +/*********************************************************************************************************/ +EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { +//TODO: +return 0; +} + +EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) { +//TODO: +return 0; +} +/*********************************************************************************************************/ + + diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglMacApi.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglMacApi.cpp new file mode 100644 index 000000000..e7f92ba87 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglMacApi.cpp @@ -0,0 +1,79 @@ + +/* +* Copyright (C) 2011 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 "EglOsApi.h" + + +//TODO: implementation for mac for all funcs +namespace EglOS { + +EGLNativeDisplayType getDefaultDisplay() {return NULL} + +bool releaseDisplay(EGLNativeDisplayType dpy) { + return false; +} + +EglConfig* pixelFormatToConfig(EGLNativeDisplayType dpy,EGLNativePixelFormatType* frmt){ + return NULL; +} + +void queryConfigs(EGLNativeDisplayType dpy,ConfigsList& listOut) { +} + +bool validNativeWin(EGLNativeWindowType win) { + return true; +} + +bool validNativePixmap(EGLNativePixmapType pix) { + return true; +} + +bool checkWindowPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativeWindowType win,EglConfig* cfg,unsigned int* width,unsigned int* height) { + return false; +} + +bool checkPixmapPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativePixmapType pix,EglConfig* cfg,unsigned int* width,unsigned int* height) { + return false; +} + +EGLNativePbufferType createPbuffer(EGLNativeDisplayType dpy,EglConfig* cfg,EglPbufferSurface* srfc){ + return NULL; +} + +EGLNativeContextType createContext(EGLNativeDisplayType dpy,EglConfig* cfg,EGLNativeContextType sharedContext) { + return NULL; +} + +bool destroyContext(EGLNativeDisplayType dpy,EGLNativeContextType ctx) { + return false; +} + + + +bool makeCurrent(EGLNativeDisplayType dpy,EglSurface* read,EglSurface* draw,EGLNativeContextType ctx){ + return false; +} + +void swapBuffers(EGLNativeDisplayType dpy,EGLNativeWindowType win) { +} + +void waitNative() { +} + +void swapInterval(EGLNativeDisplayType dpy,EGLNativeWindowType win,int interval){ +} + +}; diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglOsApi.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglOsApi.h new file mode 100644 index 000000000..6bd2b7611 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglOsApi.h @@ -0,0 +1,49 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_OS_API_H +#define EGL_OS_API_H + +#include +#include +#include "EglConfig.h" +#include "EglDisplay.h" +#include "EglPbufferSurface.h" + +#define PBUFFER_MAX_WIDTH 32767 +#define PBUFFER_MAX_HEIGHT 32767 +#define PBUFFER_MAX_PIXELS 32767*32767 + +namespace EglOS{ + + void queryConfigs(EGLNativeDisplayType dpy,ConfigsList& listOut); + bool releasePbuffer(EGLNativeDisplayType dis,EGLNativePbufferType pb); + bool destroyContext(EGLNativeDisplayType dpy,EGLNativeContextType ctx); + bool releaseDisplay(EGLNativeDisplayType dpy); + bool validNativeWin(EGLNativeWindowType win); + bool validNativePixmap(EGLNativePixmapType pix); + bool checkWindowPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativeWindowType win,EglConfig* cfg,unsigned int* width,unsigned int* height); + bool checkPixmapPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativePixmapType pix,EglConfig* cfg,unsigned int* width,unsigned int* height); + bool makeCurrent(EGLNativeDisplayType dpy,EglSurface* read,EglSurface* draw,EGLNativeContextType); + void swapBuffers(EGLNativeDisplayType dpy,EGLNativeWindowType win); + void swapInterval(EGLNativeDisplayType dpy,EGLNativeWindowType win,int interval); + void waitNative(); + + EGLNativeDisplayType getDefaultDisplay(); + EGLNativePbufferType createPbuffer(EGLNativeDisplayType dpy,EglConfig* cfg,EglPbufferSurface* pb); + EGLNativeContextType createContext(EGLNativeDisplayType dpy,EglConfig* cfg,EGLNativeContextType sharedContext); +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglPbufferSurface.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglPbufferSurface.cpp new file mode 100644 index 000000000..8bcb31a71 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglPbufferSurface.cpp @@ -0,0 +1,75 @@ +/* +* Copyright (C) 2011 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 "EglPbufferSurface.h" + +bool EglPbufferSurface::setAttrib(EGLint attrib,EGLint val) { + switch(attrib) { + case EGL_WIDTH: + if(val < 0) return false; + m_width = val; + break; + case EGL_HEIGHT: + if(val < 0) return false; + m_height = val; + break; + case EGL_LARGEST_PBUFFER: + m_largest = val; + break; + case EGL_TEXTURE_FORMAT: + if(val != EGL_NO_TEXTURE && val != EGL_TEXTURE_RGB && val != EGL_TEXTURE_RGBA) return false; + m_texFormat = val; + break; + case EGL_TEXTURE_TARGET: + if(val != EGL_NO_TEXTURE && val != EGL_TEXTURE_2D) return false; + m_texTarget = val; + break; + case EGL_MIPMAP_TEXTURE: + m_texMipmap = val; + break; + default: + return false; + } + return true; +} + +bool EglPbufferSurface::getAttrib(EGLint attrib,EGLint* val) { + switch(attrib) { + case EGL_CONFIG_ID: + *val = m_config->id(); + break; + case EGL_WIDTH: + *val = m_width; + break; + case EGL_HEIGHT: + *val = m_height; + break; + case EGL_LARGEST_PBUFFER: + *val = m_largest; + break; + case EGL_TEXTURE_FORMAT: + *val = m_texFormat; + break; + case EGL_TEXTURE_TARGET: + *val = m_texTarget; + break; + case EGL_MIPMAP_TEXTURE: + *val = m_texMipmap; + break; + default: + return false; + } + return true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglPbufferSurface.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglPbufferSurface.h new file mode 100644 index 000000000..9706714b7 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglPbufferSurface.h @@ -0,0 +1,49 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_PBUFFER_SURFACE_H +#define EGL_PBUFFER_SURFACE_H + +#include "EglSurface.h" + +class EglPbufferSurface:public EglSurface { +public: + EglPbufferSurface(EglConfig* config):EglSurface(PBUFFER,config,0,0), + m_texFormat(EGL_NO_TEXTURE), + m_texTarget(EGL_NO_TEXTURE), + m_texMipmap(EGL_FALSE), + m_largest(EGL_FALSE), + m_nativePbuffer(0){}; + + void* native(){ return (void*)m_nativePbuffer;}; + void setNativePbuffer(EGLNativePbufferType pb){ m_nativePbuffer = pb;}; + bool setAttrib(EGLint attrib,EGLint val); + bool getAttrib(EGLint attrib,EGLint* val); + void getDim(EGLint* width,EGLint* height,EGLint* largest){ + *width = m_width; + *height = m_height; + *largest = m_largest; + }; + + void getTexInfo(EGLint* format,EGLint* target){ *format = m_texFormat; *target = m_texTarget;} + +private: + EGLint m_texFormat; + EGLint m_texTarget; + EGLint m_texMipmap; + EGLint m_largest; + EGLNativePbufferType m_nativePbuffer; +}; +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglPixmapSurface.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglPixmapSurface.cpp new file mode 100644 index 000000000..37fdc12c2 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglPixmapSurface.cpp @@ -0,0 +1,53 @@ +/* +* Copyright (C) 2011 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 "EglPixmapSurface.h" + +std::set EglPixmapSurface::s_associatedPixmaps; + +bool EglPixmapSurface::alreadyAssociatedWithConfig(EGLNativePixmapType pix) { + return s_associatedPixmaps.find(pix) != s_associatedPixmaps.end(); + +} + +EglPixmapSurface::EglPixmapSurface(EGLNativePixmapType pix,EglConfig* config):EglSurface(PIXMAP,config,0,0),m_pixmap(pix) { + s_associatedPixmaps.insert(pix); +} + +EglPixmapSurface::~EglPixmapSurface() { + s_associatedPixmaps.erase(m_pixmap); +} + +bool EglPixmapSurface::getAttrib(EGLint attrib,EGLint* val) { + switch(attrib) { + case EGL_CONFIG_ID: + *val = m_config->id(); + break; + case EGL_WIDTH: + *val = m_width; + break; + case EGL_HEIGHT: + *val = m_height; + break; + case EGL_LARGEST_PBUFFER: + case EGL_TEXTURE_FORMAT: + case EGL_TEXTURE_TARGET: + case EGL_MIPMAP_TEXTURE: + break; + default: + return false; + } + return true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglPixmapSurface.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglPixmapSurface.h new file mode 100644 index 000000000..4a07327b5 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglPixmapSurface.h @@ -0,0 +1,36 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_PIXMAP_SURFACE_H +#define EGL_PIXMAP_SURFACE_H + +#include +#include +#include "EglSurface.h" + +class EglPixmapSurface: public EglSurface { +public: + EglPixmapSurface(EGLNativePixmapType pix,EglConfig* config); + ~EglPixmapSurface(); + + void* native(){ return (void*)m_pixmap;}; + bool getAttrib(EGLint attrib,EGLint* val); + + static bool alreadyAssociatedWithConfig(EGLNativePixmapType pix); +private: + EGLNativePixmapType m_pixmap; + static std::set s_associatedPixmaps; +}; +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglSurface.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglSurface.cpp new file mode 100644 index 000000000..2de243272 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglSurface.cpp @@ -0,0 +1,33 @@ +/* +* Copyright (C) 2011 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 "EglSurface.h" + +unsigned int EglSurface::s_nextSurfaceHndl = 0; + +bool EglSurface::setAttrib(EGLint attrib,EGLint val) { + switch(attrib) { + case EGL_WIDTH: + case EGL_HEIGHT: + case EGL_LARGEST_PBUFFER: + case EGL_TEXTURE_FORMAT: + case EGL_TEXTURE_TARGET: + case EGL_MIPMAP_TEXTURE: + break; + default: + return false; + } + return true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglSurface.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglSurface.h new file mode 100644 index 000000000..204bbc6ba --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglSurface.h @@ -0,0 +1,62 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_SURFACE_H +#define EGL_SURFACE_H + +#include +#include +#include + +#include "EglConfig.h" + +class EglSurface; + +typedef SmartPtr SurfacePtr; + +class EglSurface { +public: + typedef enum { + WINDOW = 0, + PBUFFER = 1, + PIXMAP = 3 + } ESurfaceType; + ESurfaceType type(){ return m_type;}; + virtual void* native() = 0; + virtual bool setAttrib(EGLint attrib,EGLint val); + virtual bool getAttrib(EGLint attrib,EGLint* val) = 0; + void setDim(int width,int height){ m_width = width; m_height = height;}; + void markForDestruction(){m_destroy = true;}; + bool destroy(){return m_destroy;}; + EglConfig* getConfig(){return m_config;}; + unsigned int getHndl(){return m_hndl;}; + +private: + static unsigned int s_nextSurfaceHndl; + ESurfaceType m_type; + bool m_destroy; + unsigned int m_hndl; + +protected: + EglSurface(ESurfaceType type,EglConfig* config,EGLint width,EGLint height):m_type(type), + m_destroy(false), + m_config(config), + m_width(width), + m_height(height){ m_hndl = ++s_nextSurfaceHndl;}; + EglConfig* m_config; + EGLint m_width; + EGLint m_height; +}; +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglThreadInfo.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglThreadInfo.cpp new file mode 100644 index 000000000..a9bfc56dc --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglThreadInfo.cpp @@ -0,0 +1,19 @@ +/* +* Copyright (C) 2011 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 "EglThreadInfo.h" +#include "EglOsApi.h" + +EglThreadInfo::EglThreadInfo():m_err(EGL_SUCCESS),m_api(EGL_OPENGL_ES_API) {} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglThreadInfo.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglThreadInfo.h new file mode 100644 index 000000000..c811508b0 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglThreadInfo.h @@ -0,0 +1,41 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_THREAD_INFO_H +#define EGL_THREAD_INFO_H + +#include +#include "EglDisplay.h" +#include "EglContext.h" +#include "EglSurface.h" +#include "EglPbufferSurface.h" + +class EglThreadInfo { +public: + + EglThreadInfo(); + void setError(EGLint err) { m_err = err;} + EGLint getError(){ return m_err;} + void destroyContextIfNotCurrent(ContextPtr context ); + void setApi(EGLenum api){m_api = api;} + EGLenum getApi(){return m_api;} + +private: + EglDisplay* m_currentDisplay; + EGLint m_err; + EGLenum m_api; +}; + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglValidate.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglValidate.cpp new file mode 100644 index 000000000..8734e5cf2 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglValidate.cpp @@ -0,0 +1,91 @@ +/* +* Copyright (C) 2011 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 "EglValidate.h" +#include + +bool EglValidate::confAttrib(EGLint attrib) { + switch(attrib) { + case EGL_BUFFER_SIZE: + case EGL_RED_SIZE: + case EGL_GREEN_SIZE: + case EGL_BLUE_SIZE: + case EGL_ALPHA_SIZE: + case EGL_BIND_TO_TEXTURE_RGB: + case EGL_BIND_TO_TEXTURE_RGBA: + case EGL_CONFIG_CAVEAT: + case EGL_CONFIG_ID: + case EGL_DEPTH_SIZE: + case EGL_LEVEL: + case EGL_MAX_PBUFFER_WIDTH: + case EGL_MAX_PBUFFER_HEIGHT: + case EGL_MAX_PBUFFER_PIXELS: + case EGL_MAX_SWAP_INTERVAL: + case EGL_MIN_SWAP_INTERVAL: + case EGL_NATIVE_RENDERABLE: + case EGL_NATIVE_VISUAL_ID: + case EGL_NATIVE_VISUAL_TYPE: + case EGL_SAMPLE_BUFFERS: + case EGL_SAMPLES: + case EGL_STENCIL_SIZE: + case EGL_SURFACE_TYPE: + case EGL_TRANSPARENT_TYPE: + case EGL_TRANSPARENT_RED_VALUE: + case EGL_TRANSPARENT_GREEN_VALUE: + case EGL_TRANSPARENT_BLUE_VALUE: + return true; + } + return false; +} + +bool EglValidate::noAttribs(const EGLint* attrib) { + return !attrib || attrib[0] == EGL_NONE ; +} + +bool EglValidate::pbufferAttribs(EGLint width,EGLint height,bool isTexFormatNoTex,bool isTexTargetNoTex) { + if(!isTexFormatNoTex) { + if (!(isPowerOf2(width) && isPowerOf2(height))) return false; + } + return isTexFormatNoTex == isTexTargetNoTex ; +} + +bool EglValidate::releaseContext(EGLContext ctx,EGLSurface s1,EGLSurface s2) { + return (ctx == EGL_NO_CONTEXT) && + (s1 == EGL_NO_SURFACE) && + (s2 == EGL_NO_SURFACE); +} + +bool EglValidate::badContextMatch(EGLContext ctx,EGLSurface s1,EGLSurface s2) { + return ctx != EGL_NO_CONTEXT ? (s1 == EGL_NO_SURFACE || s2 == EGL_NO_SURFACE): + (s1 != EGL_NO_SURFACE || s2 != EGL_NO_SURFACE); +} + +bool EglValidate::surfaceTarget(EGLint target) { + return target == EGL_READ || target == EGL_DRAW; +} + +bool EglValidate::engine(EGLint engine) { + return engine == EGL_CORE_NATIVE_ENGINE; +} + +bool EglValidate::stringName(EGLint name) { + return name == EGL_VENDOR || + name == EGL_VERSION || + name == EGL_EXTENSIONS; +} + +bool EglValidate::supportedApi(EGLenum api) { + return api == EGL_OPENGL_ES_API; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglValidate.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglValidate.h new file mode 100644 index 000000000..532584f08 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglValidate.h @@ -0,0 +1,33 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_VALIDATE_H +#define EGL_VALIDATE_H + +#include + +class EglValidate { +public: + static bool confAttrib(EGLint attrib); + static bool noAttribs(const EGLint* attrib); + static bool pbufferAttribs(EGLint width,EGLint height,bool texFormatIsNoTex,bool texTargetIsNoTex); + static bool releaseContext(EGLContext ctx,EGLSurface s1,EGLSurface s2); + static bool badContextMatch(EGLContext ctx,EGLSurface s1,EGLSurface s2); + static bool surfaceTarget(EGLint target); + static bool engine(EGLint engine); + static bool stringName(EGLint name); + static bool supportedApi(EGLenum api); +}; +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowSurface.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowSurface.cpp new file mode 100644 index 000000000..0e075223a --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowSurface.cpp @@ -0,0 +1,53 @@ +/* +* Copyright (C) 2011 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 "EglWindowSurface.h" + +std::set EglWindowSurface::s_associatedWins; + +bool EglWindowSurface::alreadyAssociatedWithConfig(EGLNativeWindowType win) { + return s_associatedWins.find(win) != s_associatedWins.end(); + +} + +EglWindowSurface::EglWindowSurface(EGLNativeWindowType win,EglConfig* config,unsigned int width,unsigned int height):EglSurface(WINDOW,config,width,height),m_win(win){ + s_associatedWins.insert(win); +} + +EglWindowSurface:: ~EglWindowSurface() { + s_associatedWins.erase(m_win); +} + +bool EglWindowSurface::getAttrib(EGLint attrib,EGLint* val) { + switch(attrib) { + case EGL_CONFIG_ID: + *val = m_config->id(); + break; + case EGL_WIDTH: + *val = m_width; + break; + case EGL_HEIGHT: + *val = m_height; + break; + case EGL_LARGEST_PBUFFER: + case EGL_TEXTURE_FORMAT: + case EGL_TEXTURE_TARGET: + case EGL_MIPMAP_TEXTURE: + break; + default: + return false; + } + return true; +} diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowSurface.h b/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowSurface.h new file mode 100644 index 000000000..175224148 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowSurface.h @@ -0,0 +1,36 @@ +/* +* Copyright (C) 2011 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. +*/ +#ifndef EGL_WINDOW_SURFACE_H +#define EGL_WINDOW_SURFACE_H + +#include +#include +#include "EglSurface.h" +#include "EglConfig.h" + +class EglWindowSurface: public EglSurface { +public: + EglWindowSurface(EGLNativeWindowType win,EglConfig* config,unsigned width,unsigned int height); + ~EglWindowSurface(); + bool getAttrib(EGLint attrib,EGLint* val); + void* native(){ return (void *)m_win;}; + + static bool alreadyAssociatedWithConfig(EGLNativeWindowType win); +private: + EGLNativeWindowType m_win; + static std::set s_associatedWins; +}; +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowsApi.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowsApi.cpp new file mode 100644 index 000000000..bd642b550 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglWindowsApi.cpp @@ -0,0 +1,278 @@ +/* +* Copyright (C) 2011 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 "EglOsApi.h" +#include +#include + +#define IS_TRUE(a) \ + if(a != true) return false; + +namespace EglOS{ +bool WGLExtensionSupported(const char *extension_name) +{ + // this is pointer to function which returns pointer to string with list of all wgl extensions + PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglGetExtensionsStringEXT = NULL; + + // determine pointer to wglGetExtensionsStringEXT function + _wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) wglGetProcAddress("wglGetExtensionsStringEXT"); + + if (strstr(_wglGetExtensionsString(), extension_name) == NULL) + { + // string was not found + return false; + } + + // extension is supported + return true; +} + +EGLNativeDisplayType getDefaultDisplay() { + return GetDC(); +} + +bool releaseDisplay(EGLNativeDisplay dpy) { + return DeleteDC(dpy); +} + + + +EglConfig* pixelFormatToConfig(EGLNativeDisplayType dpy,EGLNativePixelFormatType* frmt,int index){ + + int supportedSurfaces,visualType,visualId; + int caveat,transparentType,samples; + int tRed,tGreen,tBlue; + int pMaxWidth,pMaxHeight,pMaxPixels; + int configId,level,renderable; + bool window,bitmap,pbuffer,transparent; + + if(frmt->iPixelType != PFD_TYPE_RGBA) return NULL; // other formats are not supported yet + + supportedSurfaces = 0; + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_DRAW_TO_WINDOW_ARB,&window)); + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_DRAW_TO_BITMAP_ARB,&bitmap)); + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_DRAW_TO_PBUFFER_ARB,&pbuffer)); + if(window) supportedSurfaces |= EGL_WINDOW_BIT; + if(bitmap) supportedSurfaces |= EGL_PIXMAP_BIT; + if(pbuffer) supportedSurfaces |= EGL_PBUFFER_BIT; + + //default values + visualId = 0; + visualType = EGL_NONE; + caveat = EGL_NONE; + pMaxWidth = PBUFFER_MAX_WIDTH; + pMaxHeight = PBUFFER_MAX_HEIGHT; + pMaxPixels = PBUFFER_MAX_PIXELS; + samples = 0 ; + level = 0 ; + renderable = EGL_FALSE; + + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_TRANSPARENT_ARB,&transparent)); + if(transparent) { + transparentType = EGL_TRANSPARENT_RGB; + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_TRANSPARENT_RED_VALUE_ARB,&tRed)); + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_TRANSPARENT_GREEN_VALUE_ARB,&tGreen)); + IS_TRUE(wglGetPixelFormatAttribivARB(dpy,index,0,1,WGL_TRANSPARENT_BLUE_VALUE_ARB,&tBlue)); + } else { + transparentType = EGL_NONE; + } + + return new EglConfig(frmt->cRedBits,frmt->cGreenBits,frmt->cBlueBits,frmt->cAlphaBits,caveat, + index,frmt->cDepthBits,level,pMaxWidth,pMaxHeight,pMaxPixels,renderable, + visualId,visualType,samples,frmt->cStencilBits,supportedSurfaces,transparentType,tRed,tGreen,tBlue,frmt); +} + +void queryConfigs(EGLNativeDisplayType dpy,ConfigList& listOut) { + PIXELFORMATDESCRIPTOR pfd; + int iPixelFormat = 1; + + //quering num of formats + nFormats = DescribePixelFormat(dpy, iPixelFormat,sizeof(PIXELFORMATDESCRIPTOR), &pfd); + EglConfig* p = pixelFormatToConfig(dpy,&pfd,iPixelFormat); + //inserting first format + if(p) listOut.push_front(p); + + //inserting rest of formats + for(iPixelFormat++;iPixelFormat < nFormats; iPixelFormat++) { + DescribePixelFormat(dpy, iPixelFormat,sizeof(PIXELFORMATDESCRIPTOR), &pfd); + EglConfig* pConfig = pixelFormatToConfig(dpy,&pfd,iPixelFormat); + if(pConfig) listOut.push_front(pConfig); + } + +} + + +bool validNativeWin(EGLNativeWindowType win) { + return IsWindow(win); +} + +bool validNativePixmap(EGLNativePixmapType pix) { + BITMAP bm; + return GetObject(pix, sizeof(BITMAP), (LPSTR)&bm); +} + +static bool setPixelFormat(EGLNativeDisplayType dpy,EglConfig* cfg) { + int iPixelFormat = ChoosePixelFormat(dpy,cfg->nativeConfig()); + if(!iPixelFormat) return false; + if(!SetPixelFormat(dpy,iPixelFormat,cfg->nativeConfig())) return false; + return true; +} + +bool checkWindowPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativeWindowType win,EglConfig* cfg,unsigned int* width,unsigned int* height) { + RECT r; + if(!GetClientRect(win,&r)) return false; + *width = r.right - r.left; + *height = r.bottom - r.top; + + return setPixelFormat(dpy,cfg); +} + +bool checkPixmapPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativePixmapType pix,EglConfig* cfg) { + + BITMAP bm; + if(!GetObject(pix, sizeof(BITMAP), (LPSTR)&bm)) return false; + + *width = bm.bmWidth; + *height = bm.bmHeight; + + return setPixelFormat(dpy,cfg); +} + +EGLNativePbufferType createPbuffer(EGLNativeDisplayType dpy,EglConfig* cfg,EglPbSurface* pbSurface) { + + //converting configuration into WGL pixel Format + EGLint red,green,blue,alpha,depth,stencil; + bool gotAttribs = getConfAttrib(EGL_RED_SIZE,&red) && + getConfAttrib(EGL_GREEN_SIZE,&green) && + getConfAttrib(EGL_BLUE_SIZE,&blue) && + getConfAttrib(EGL_ALPHA_SIZE,&alpha) && + getConfAttrib(EGL_DEPTH_SIZE,&depth) && + getConfAttrib(EGL_STENCIL_SIZE,&stencil) ; + + if(!gotAttribs) return false; + int wglPixelFormatAttribs[] = { + WGL_SUPPORT_OPENGL_ARB ,TRUE, + WGL_DRAW_TO_BUFFER_ARB ,TRUE, + WGL_BIND_TO_TEXTURE_RGBA_ARB ,TRUE, + WGL_COLOR_BITS_ARB ,red+green+blue, + WGL_RED_BITS_ARB ,red, + WGL_GREEN_BITS_ARB ,green, + WGL_BLUE_BITS_ARB ,blue, + WGL_ALPHA_BITS_ARB ,alpha, + WGL_STENCIL_BITS_ARB ,stencil, + WGL_DEPTH_BITS_ARB ,depth, + WGL_DOUBLE_BUFFER_ARB ,TRUE, + 0 + }; + + int pixfmt; + unsigned int numpf; + if(!wglChoosePixelFormatARB(dpy,wglPixelFormatAttribs, NULL, 1, &pixfmt, &numpf)) { + DWORD err = GetLastError(); + return NULL; + } + + EGLint width,height,largest,texTarget,texFormat; + pbSurface->getDim(&width,&height,&largest); + pbSurface->getTexInfo(&texTarget,&texFormat); + + int wglTexFormat = WGL_NO_TEXTURE_ARB; + int wglTexTarget = (texTarget == EGL_TEXTURE_2D)? WGL_TEXTURE_2D_ARB: + WGL_NO_TEXTURE_ARB; + + switch(texFormat) { + case EGL_TEXTURE_RGB: + wglTexFormat = WGL_TEXTURE_RGB_ARB; + break; + case EGL_TEXTURE_RGBA: + wglTexFormat = WGL_TEXTURE_RGB_ARBA; + break; + } + + int pbAttribs[] = { + WGL_TEXTURE_TARGET_ARB ,wglTexTarget, + WGL_TEXTURE_FORMAT_ARB ,wglTexFormat, + WGL_TEXTURE_LARGEST_ARB ,largest, + 0 + }; + EGLNativePbufferType pb = wglCreatePbufferARB(dpy,pixfmt,width,height,pbAttribs); + if(!pb) { + DWORD err = GetLastError(); + return NULL; + } + return pb; +} + +bool releasePbuffer(EGLNativeDisplayType dis,EGLNativePbufferType pb) { + if(wglReleasePbufferDCARB(pb,dis) || wglDestroyPbufferArb(pb)){ + DWORD err = GetLastError(); + return false; + } + return true; +} + +EGLNativeContextType createContext(EGLNativeDisplayType dpy,EglConfig* cfg,EGLNativeContextType sharedContext) { + + EGLNativeContextType ctx = NULL; + + if(!setPixelFormat(dpy,cfg)) return NULL; + ctx = wglCreateContext(dpy); + if(ctx && sharedContext) { + if(!wglShareLists(sharedContext,ctx)) { + wglDeleteContext(ctx); + return NULL; + } + } + return ctx; +} + +bool destroyContext(EGLNativeDisplayType dpy,EGLNativeContextType ctx) { + if(!wglDeleteContext(ctx)) { + DWORD err = GetLastError(); + return false; + } + return true; +} + +bool makeCurrent(EGLNativeDisplayType dpy,EglSurface* read,EglSurface* draw,EGLNativeContextType ctx) { + return ctx ? :wglMakeCurrent(dpy,NULL): wglMakeContextCurrentARB(dpy,draw->native(),read->native()); + + +} + +void swapBuffers(EGLNativeDisplayType dpy,EGLNativeWindowType win) { + if(!SwapBuffers(dpy)) { + DWORD err = GetLastError(); + } + +} + + +void waitNative(){} + +void swapInterval(EGLNativeDisplayType dpy,EGLNativeWindowType win,int interval) { + + PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = NULL; + + if (WGLExtensionSupported("WGL_EXT_swap_control")) + { + // Extension is supported, init pointers. + wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) LogGetProcAddress("wglSwapIntervalEXT"); + + } + wglSwapIntervalEXT(interval); +} + +}; diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/EglX11Api.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/EglX11Api.cpp new file mode 100644 index 000000000..2f57f3a8c --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/EglX11Api.cpp @@ -0,0 +1,216 @@ +/* +* Copyright (C) 2011 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 "EglOsApi.h" +#include +#include + + +#define IS_SUCCESS(a) \ + if(a != Success) return false; + +namespace EglOS { + +EGLNativeDisplayType getDefaultDisplay() {return XOpenDisplay(0);} + +bool releaseDisplay(EGLNativeDisplayType dpy) { + return XCloseDisplay(dpy); +} + +EglConfig* pixelFormatToConfig(EGLNativeDisplayType dpy,EGLNativePixelFormatType* frmt){ + + int bSize,red,green,blue,alpha,depth,stencil; + int supportedSurfaces,visualType,visualId; + int caveat,transparentType,samples; + int tRed,tGreen,tBlue; + int pMaxWidth,pMaxHeight,pMaxPixels; + int tmp; + int configId,level,renderable; + + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_TRANSPARENT_TYPE,&tmp)); + if(tmp == GLX_TRANSPARENT_INDEX) { + return NULL; // not supporting transparent index + } else if( tmp == GLX_NONE) { + transparentType = EGL_NONE; + } else { + transparentType = EGL_TRANSPARENT_RGB; + + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_TRANSPARENT_RED_VALUE,&tRed)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_TRANSPARENT_GREEN_VALUE,&tGreen)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_TRANSPARENT_BLUE_VALUE,&tBlue)); + } + + + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_BUFFER_SIZE,&bSize)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_RED_SIZE,&red)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_GREEN_SIZE,&green)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_BLUE_SIZE,&blue)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_ALPHA_SIZE,&alpha)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_DEPTH_SIZE,&depth)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_STENCIL_SIZE,&stencil)); + + + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_X_RENDERABLE,&renderable)); + + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_X_VISUAL_TYPE,&visualType)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_VISUAL_ID,&visualId)); + + //supported surfaces types + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_DRAWABLE_TYPE,&tmp)); + supportedSurfaces = 0; + if(tmp & GLX_WINDOW_BIT) { + supportedSurfaces |= EGL_WINDOW_BIT; + } else { + visualId = 0; + visualType = EGL_NONE; + } + if(tmp & GLX_PIXMAP_BIT) supportedSurfaces |= EGL_PIXMAP_BIT; + if(tmp & GLX_PBUFFER_BIT) supportedSurfaces |= EGL_PBUFFER_BIT; + + caveat = 0; + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_CONFIG_CAVEAT,&tmp)); + if (tmp == GLX_NONE) caveat = EGL_NONE; + else if(tmp == GLX_SLOW_CONFIG) caveat = EGL_SLOW_CONFIG; + else if(tmp == GLX_NON_CONFORMANT_CONFIG) caveat = EGL_NON_CONFORMANT_CONFIG; + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_MAX_PBUFFER_WIDTH,&pMaxWidth)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_MAX_PBUFFER_HEIGHT,&pMaxHeight)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_MAX_PBUFFER_HEIGHT,&pMaxPixels)); + + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_LEVEL,&level)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_FBCONFIG_ID,&configId)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,*frmt,GLX_SAMPLES,&samples)); + + + return new EglConfig(red,green,blue,alpha,caveat,configId,depth,level,pMaxWidth,pMaxHeight, + pMaxPixels,renderable,visualId,visualType,samples,stencil, + supportedSurfaces,transparentType,tRed,tGreen,tBlue,*frmt); +} + +void queryConfigs(EGLNativeDisplayType dpy,ConfigsList& listOut) { + int n; + EGLNativePixelFormatType* frmtList = glXGetFBConfigs(dpy,0,&n); + for(int i =0 ;i < n ; i++) { + EglConfig* conf = pixelFormatToConfig(dpy,&frmtList[i]); + if(conf) listOut.push_back(conf); + } + listOut.sort(); + XFree(frmtList); +} + +bool validNativeWin(EGLNativeWindowType win) { + //TODO: use XGetgeometry to check validity + return true; +} + +bool validNativePixmap(EGLNativePixmapType pix) { + //TODO: use XGetgeometry to check validity + return true; +} + +bool checkWindowPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativeWindowType win,EglConfig* cfg,unsigned int* width,unsigned int* height) { +//TODO: to check what does ATI & NVIDIA enforce on win pixelformat + unsigned int depth,configDepth,border; + int r,g,b,x,y; + IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_RED_SIZE,&r)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_GREEN_SIZE,&g)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_BLUE_SIZE,&b)); + configDepth = r + g + b; + Window root; + if(!XGetGeometry(dpy,win,&root,&x,&y,width,height,&border,&depth)) return false; + return depth >= configDepth; +} + +bool checkPixmapPixelFormatMatch(EGLNativeDisplayType dpy,EGLNativePixmapType pix,EglConfig* cfg,unsigned int* width,unsigned int* height) { + unsigned int depth,configDepth,border; + int r,g,b,x,y; + IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_RED_SIZE,&r)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_GREEN_SIZE,&g)); + IS_SUCCESS(glXGetFBConfigAttrib(dpy,cfg->nativeConfig(),GLX_BLUE_SIZE,&b)); + configDepth = r + g + b; + Window root; + if(!XGetGeometry(dpy,pix,&root,&x,&y,width,height,&border,&depth)) return false; + return depth >= configDepth; +} + +EGLNativePbufferType createPbuffer(EGLNativeDisplayType dpy,EglConfig* cfg,EglPbufferSurface* srfc){ + EGLint width,height,largest; + srfc->getDim(&width,&height,&largest); + + int attribs[] = { + GLX_PBUFFER_WIDTH ,width, + GLX_PBUFFER_HEIGHT ,height, + GLX_LARGEST_PBUFFER ,largest, + None + }; + return glXCreatePbuffer(dpy,cfg->nativeConfig(),attribs); +} + +bool releasePbuffer(EGLNativeDisplayType dis,EGLNativePbufferType pb) { + glXDestroyPbuffer(dis,pb); + + return true; +} + +EGLNativeContextType createContext(EGLNativeDisplayType dpy,EglConfig* cfg,EGLNativeContextType sharedContext) { + return glXCreateNewContext(dpy,cfg->nativeConfig(),GLX_RGBA_TYPE,sharedContext,true); +} + +bool destroyContext(EGLNativeDisplayType dpy,EGLNativeContextType ctx) { + glXDestroyContext(dpy,ctx); + return true; +} + +GLXDrawable convertSurface(EglSurface* srfc) { + if(!srfc) return None; + switch(srfc->type()){ + case EglSurface::PIXMAP: + return (GLXPixmap)srfc->native(); + case EglSurface::PBUFFER: + return (GLXPbuffer)srfc->native(); + case EglSurface::WINDOW: + default: + return (GLXWindow)srfc->native(); + } +} + + +bool makeCurrent(EGLNativeDisplayType dpy,EglSurface* read,EglSurface* draw,EGLNativeContextType ctx){ + + +return glXMakeContextCurrent(dpy,convertSurface(draw),convertSurface(read),ctx); +} + +void swapBuffers(EGLNativeDisplayType dpy,EGLNativeWindowType win) { + glXSwapBuffers(dpy,win); +} + +void waitNative() { + glXWaitX(); +} + +void swapInterval(EGLNativeDisplayType dpy,EGLNativeWindowType win,int interval){ + const char* extensions = glXQueryExtensionsString(dpy,DefaultScreen(dpy)); + typedef void (*GLXSWAPINTERVALEXT)(Display*,GLXDrawable,int); + GLXSWAPINTERVALEXT glXSwapIntervalEXT = NULL; + + if(strstr(extensions,"EXT_swap_control")) { + glXSwapIntervalEXT = (GLXSWAPINTERVALEXT)glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT"); + } + if(glXSwapIntervalEXT) { + glXSwapIntervalEXT(dpy,win,interval); + } +} + +}; diff --git a/tools/emulator/opengl/host/libs/Translator/EGL/ThreadInfo.cpp b/tools/emulator/opengl/host/libs/Translator/EGL/ThreadInfo.cpp new file mode 100644 index 000000000..ed2880f4a --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/EGL/ThreadInfo.cpp @@ -0,0 +1,58 @@ +/* +* Copyright (C) 2011 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 + +__thread ThreadInfo* thread = NULL; + +void ThreadInfo::updateInfo(void* eglCtx,void* dpy,void* glesCtx,ShareGroupPtr share,ObjectNameManager* manager) { + eglContext = eglCtx; + eglDisplay = dpy; + glesContext = glesCtx; + shareGroup = share; + objManager = manager; +} + +#ifdef __linux__ +ThreadInfo* getThreadInfo(){ + if(!thread) { + thread = new ThreadInfo(); + } + return thread; +} + +#else +#include +static thread_store_t s_tls = THREAD_STORE_INITIALIZER; + +static void tlsDestruct(void *ptr) +{ + if (ptr) { + ThreadInfo *ti = (ThreadInfo *)ptr; + delete ti; + } +} + +RenderThreadInfo *getRenderThreadInfo() +{ + ThreadInfo *ti = (ThreadInfo *)thread_store_get(&s_tls); + if (!ti) { + ti = new RenderThreadInfo(); + thread_store_set(&s_tls, ti, tlsDestruct); + } + return ti; +} +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/include/EGL/egl.h b/tools/emulator/opengl/host/libs/Translator/include/EGL/egl.h new file mode 100644 index 000000000..99ea342a4 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/EGL/egl.h @@ -0,0 +1,329 @@ +/* -*- mode: c; tab-width: 8; -*- */ +/* vi: set sw=4 ts=8: */ +/* Reference version of egl.h for EGL 1.4. + * $Revision: 9356 $ on $Date: 2009-10-21 02:52:25 -0700 (Wed, 21 Oct 2009) $ + */ + +/* +** Copyright (c) 2007-2009 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __egl_h_ +#define __egl_h_ + +/* All platform-dependent types and macro boilerplate (such as EGLAPI + * and EGLAPIENTRY) should go in eglplatform.h. + */ +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* EGL Types */ +/* EGLint is defined in eglplatform.h */ +typedef unsigned int EGLBoolean; +typedef unsigned int EGLenum; +typedef void *EGLConfig; +typedef void *EGLContext; +typedef void *EGLDisplay; +typedef void *EGLSurface; +typedef void *EGLClientBuffer; + +/* EGL Versioning */ +#define EGL_VERSION_1_0 1 +#define EGL_VERSION_1_1 1 +#define EGL_VERSION_1_2 1 +#define EGL_VERSION_1_3 1 +#define EGL_VERSION_1_4 1 + +/* EGL Enumerants. Bitmasks and other exceptional cases aside, most + * enums are assigned unique values starting at 0x3000. + */ + +/* EGL aliases */ +#define EGL_FALSE 0 +#define EGL_TRUE 1 + +/* Out-of-band handle values */ +#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0) +#define EGL_NO_CONTEXT ((EGLContext)0) +#define EGL_NO_DISPLAY ((EGLDisplay)0) +#define EGL_NO_SURFACE ((EGLSurface)0) + +/* Out-of-band attribute value */ +#define EGL_DONT_CARE ((EGLint)-1) + +/* Errors / GetError return values */ +#define EGL_SUCCESS 0x3000 +#define EGL_NOT_INITIALIZED 0x3001 +#define EGL_BAD_ACCESS 0x3002 +#define EGL_BAD_ALLOC 0x3003 +#define EGL_BAD_ATTRIBUTE 0x3004 +#define EGL_BAD_CONFIG 0x3005 +#define EGL_BAD_CONTEXT 0x3006 +#define EGL_BAD_CURRENT_SURFACE 0x3007 +#define EGL_BAD_DISPLAY 0x3008 +#define EGL_BAD_MATCH 0x3009 +#define EGL_BAD_NATIVE_PIXMAP 0x300A +#define EGL_BAD_NATIVE_WINDOW 0x300B +#define EGL_BAD_PARAMETER 0x300C +#define EGL_BAD_SURFACE 0x300D +#define EGL_CONTEXT_LOST 0x300E /* EGL 1.1 - IMG_power_management */ + +/* Reserved 0x300F-0x301F for additional errors */ + +/* Config attributes */ +#define EGL_BUFFER_SIZE 0x3020 +#define EGL_ALPHA_SIZE 0x3021 +#define EGL_BLUE_SIZE 0x3022 +#define EGL_GREEN_SIZE 0x3023 +#define EGL_RED_SIZE 0x3024 +#define EGL_DEPTH_SIZE 0x3025 +#define EGL_STENCIL_SIZE 0x3026 +#define EGL_CONFIG_CAVEAT 0x3027 +#define EGL_CONFIG_ID 0x3028 +#define EGL_LEVEL 0x3029 +#define EGL_MAX_PBUFFER_HEIGHT 0x302A +#define EGL_MAX_PBUFFER_PIXELS 0x302B +#define EGL_MAX_PBUFFER_WIDTH 0x302C +#define EGL_NATIVE_RENDERABLE 0x302D +#define EGL_NATIVE_VISUAL_ID 0x302E +#define EGL_NATIVE_VISUAL_TYPE 0x302F +#define EGL_SAMPLES 0x3031 +#define EGL_SAMPLE_BUFFERS 0x3032 +#define EGL_SURFACE_TYPE 0x3033 +#define EGL_TRANSPARENT_TYPE 0x3034 +#define EGL_TRANSPARENT_BLUE_VALUE 0x3035 +#define EGL_TRANSPARENT_GREEN_VALUE 0x3036 +#define EGL_TRANSPARENT_RED_VALUE 0x3037 +#define EGL_NONE 0x3038 /* Attrib list terminator */ +#define EGL_BIND_TO_TEXTURE_RGB 0x3039 +#define EGL_BIND_TO_TEXTURE_RGBA 0x303A +#define EGL_MIN_SWAP_INTERVAL 0x303B +#define EGL_MAX_SWAP_INTERVAL 0x303C +#define EGL_LUMINANCE_SIZE 0x303D +#define EGL_ALPHA_MASK_SIZE 0x303E +#define EGL_COLOR_BUFFER_TYPE 0x303F +#define EGL_RENDERABLE_TYPE 0x3040 +#define EGL_MATCH_NATIVE_PIXMAP 0x3041 /* Pseudo-attribute (not queryable) */ +#define EGL_CONFORMANT 0x3042 + +/* Reserved 0x3041-0x304F for additional config attributes */ + +/* Config attribute values */ +#define EGL_SLOW_CONFIG 0x3050 /* EGL_CONFIG_CAVEAT value */ +#define EGL_NON_CONFORMANT_CONFIG 0x3051 /* EGL_CONFIG_CAVEAT value */ +#define EGL_TRANSPARENT_RGB 0x3052 /* EGL_TRANSPARENT_TYPE value */ +#define EGL_RGB_BUFFER 0x308E /* EGL_COLOR_BUFFER_TYPE value */ +#define EGL_LUMINANCE_BUFFER 0x308F /* EGL_COLOR_BUFFER_TYPE value */ + +/* More config attribute values, for EGL_TEXTURE_FORMAT */ +#define EGL_NO_TEXTURE 0x305C +#define EGL_TEXTURE_RGB 0x305D +#define EGL_TEXTURE_RGBA 0x305E +#define EGL_TEXTURE_2D 0x305F + +/* Config attribute mask bits */ +#define EGL_PBUFFER_BIT 0x0001 /* EGL_SURFACE_TYPE mask bits */ +#define EGL_PIXMAP_BIT 0x0002 /* EGL_SURFACE_TYPE mask bits */ +#define EGL_WINDOW_BIT 0x0004 /* EGL_SURFACE_TYPE mask bits */ +#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020 /* EGL_SURFACE_TYPE mask bits */ +#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040 /* EGL_SURFACE_TYPE mask bits */ +#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200 /* EGL_SURFACE_TYPE mask bits */ +#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400 /* EGL_SURFACE_TYPE mask bits */ + +#define EGL_OPENGL_ES_BIT 0x0001 /* EGL_RENDERABLE_TYPE mask bits */ +#define EGL_OPENVG_BIT 0x0002 /* EGL_RENDERABLE_TYPE mask bits */ +#define EGL_OPENGL_ES2_BIT 0x0004 /* EGL_RENDERABLE_TYPE mask bits */ +#define EGL_OPENGL_BIT 0x0008 /* EGL_RENDERABLE_TYPE mask bits */ + +/* QueryString targets */ +#define EGL_VENDOR 0x3053 +#define EGL_VERSION 0x3054 +#define EGL_EXTENSIONS 0x3055 +#define EGL_CLIENT_APIS 0x308D + +/* QuerySurface / SurfaceAttrib / CreatePbufferSurface targets */ +#define EGL_HEIGHT 0x3056 +#define EGL_WIDTH 0x3057 +#define EGL_LARGEST_PBUFFER 0x3058 +#define EGL_TEXTURE_FORMAT 0x3080 +#define EGL_TEXTURE_TARGET 0x3081 +#define EGL_MIPMAP_TEXTURE 0x3082 +#define EGL_MIPMAP_LEVEL 0x3083 +#define EGL_RENDER_BUFFER 0x3086 +#define EGL_VG_COLORSPACE 0x3087 +#define EGL_VG_ALPHA_FORMAT 0x3088 +#define EGL_HORIZONTAL_RESOLUTION 0x3090 +#define EGL_VERTICAL_RESOLUTION 0x3091 +#define EGL_PIXEL_ASPECT_RATIO 0x3092 +#define EGL_SWAP_BEHAVIOR 0x3093 +#define EGL_MULTISAMPLE_RESOLVE 0x3099 + +/* EGL_RENDER_BUFFER values / BindTexImage / ReleaseTexImage buffer targets */ +#define EGL_BACK_BUFFER 0x3084 +#define EGL_SINGLE_BUFFER 0x3085 + +/* OpenVG color spaces */ +#define EGL_VG_COLORSPACE_sRGB 0x3089 /* EGL_VG_COLORSPACE value */ +#define EGL_VG_COLORSPACE_LINEAR 0x308A /* EGL_VG_COLORSPACE value */ + +/* OpenVG alpha formats */ +#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B /* EGL_ALPHA_FORMAT value */ +#define EGL_VG_ALPHA_FORMAT_PRE 0x308C /* EGL_ALPHA_FORMAT value */ + +/* Constant scale factor by which fractional display resolutions & + * aspect ratio are scaled when queried as integer values. + */ +#define EGL_DISPLAY_SCALING 10000 + +/* Unknown display resolution/aspect ratio */ +#define EGL_UNKNOWN ((EGLint)-1) + +/* Back buffer swap behaviors */ +#define EGL_BUFFER_PRESERVED 0x3094 /* EGL_SWAP_BEHAVIOR value */ +#define EGL_BUFFER_DESTROYED 0x3095 /* EGL_SWAP_BEHAVIOR value */ + +/* CreatePbufferFromClientBuffer buffer types */ +#define EGL_OPENVG_IMAGE 0x3096 + +/* QueryContext targets */ +#define EGL_CONTEXT_CLIENT_TYPE 0x3097 + +/* CreateContext attributes */ +#define EGL_CONTEXT_CLIENT_VERSION 0x3098 + +/* Multisample resolution behaviors */ +#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A /* EGL_MULTISAMPLE_RESOLVE value */ +#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B /* EGL_MULTISAMPLE_RESOLVE value */ + +/* BindAPI/QueryAPI targets */ +#define EGL_OPENGL_ES_API 0x30A0 +#define EGL_OPENVG_API 0x30A1 +#define EGL_OPENGL_API 0x30A2 + +/* GetCurrentSurface targets */ +#define EGL_DRAW 0x3059 +#define EGL_READ 0x305A + +/* WaitNative engines */ +#define EGL_CORE_NATIVE_ENGINE 0x305B + +/* EGL 1.2 tokens renamed for consistency in EGL 1.3 */ +#define EGL_COLORSPACE EGL_VG_COLORSPACE +#define EGL_ALPHA_FORMAT EGL_VG_ALPHA_FORMAT +#define EGL_COLORSPACE_sRGB EGL_VG_COLORSPACE_sRGB +#define EGL_COLORSPACE_LINEAR EGL_VG_COLORSPACE_LINEAR +#define EGL_ALPHA_FORMAT_NONPRE EGL_VG_ALPHA_FORMAT_NONPRE +#define EGL_ALPHA_FORMAT_PRE EGL_VG_ALPHA_FORMAT_PRE + +/* EGL extensions must request enum blocks from the Khronos + * API Registrar, who maintains the enumerant registry. Submit + * a bug in Khronos Bugzilla against task "Registry". + */ + + + +/* EGL Functions */ + +EGLAPI EGLint EGLAPIENTRY eglGetError(void); + +EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id); +EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor); +EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy); + +EGLAPI const char * EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name); + +EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, + EGLint config_size, EGLint *num_config); +EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, + EGLConfig *configs, EGLint config_size, + EGLint *num_config); +EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, + EGLint attribute, EGLint *value); + +EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, + EGLNativeWindowType win, + const EGLint *attrib_list); +EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, + const EGLint *attrib_list); +EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, + EGLNativePixmapType pixmap, + const EGLint *attrib_list); +EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface); +EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, + EGLint attribute, EGLint *value); + +EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api); +EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void); + +EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void); + +EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void); + +EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer( + EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, + EGLConfig config, const EGLint *attrib_list); + +EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, + EGLint attribute, EGLint value); +EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); +EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer); + + +EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval); + + +EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, + EGLContext share_context, + const EGLint *attrib_list); +EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx); +EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, + EGLSurface read, EGLContext ctx); + +EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void); +EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw); +EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void); +EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, + EGLint attribute, EGLint *value); + +EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void); +EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine); +EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface); +EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, + EGLNativePixmapType target); + +/* This is a generic function pointer type, whose name indicates it must + * be cast to the proper type *and calling convention* before use. + */ +typedef void (*__eglMustCastToProperFunctionPointerType)(void); + +/* Now, define eglGetProcAddress using the generic function ptr. type */ +EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY + eglGetProcAddress(const char *procname); + +#ifdef __cplusplus +} +#endif + +#endif /* __egl_h_ */ diff --git a/tools/emulator/opengl/host/libs/Translator/include/EGL/eglext.h b/tools/emulator/opengl/host/libs/Translator/include/EGL/eglext.h new file mode 100644 index 000000000..1ffcd563f --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/EGL/eglext.h @@ -0,0 +1,244 @@ +#ifndef __eglext_h_ +#define __eglext_h_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2007-2010 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#include + +/*************************************************************/ + +/* Header file version number */ +/* Current version at http://www.khronos.org/registry/egl/ */ +/* $Revision: 11249 $ on $Date: 2010-05-05 09:54:28 -0700 (Wed, 05 May 2010) $ */ +#define EGL_EGLEXT_VERSION 5 + +#ifndef EGL_KHR_config_attribs +#define EGL_KHR_config_attribs 1 +#define EGL_CONFORMANT_KHR 0x3042 /* EGLConfig attribute */ +#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR 0x0020 /* EGL_SURFACE_TYPE bitfield */ +#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR 0x0040 /* EGL_SURFACE_TYPE bitfield */ +#endif + +#ifndef EGL_KHR_lock_surface +#define EGL_KHR_lock_surface 1 +#define EGL_READ_SURFACE_BIT_KHR 0x0001 /* EGL_LOCK_USAGE_HINT_KHR bitfield */ +#define EGL_WRITE_SURFACE_BIT_KHR 0x0002 /* EGL_LOCK_USAGE_HINT_KHR bitfield */ +#define EGL_LOCK_SURFACE_BIT_KHR 0x0080 /* EGL_SURFACE_TYPE bitfield */ +#define EGL_OPTIMAL_FORMAT_BIT_KHR 0x0100 /* EGL_SURFACE_TYPE bitfield */ +#define EGL_MATCH_FORMAT_KHR 0x3043 /* EGLConfig attribute */ +#define EGL_FORMAT_RGB_565_EXACT_KHR 0x30C0 /* EGL_MATCH_FORMAT_KHR value */ +#define EGL_FORMAT_RGB_565_KHR 0x30C1 /* EGL_MATCH_FORMAT_KHR value */ +#define EGL_FORMAT_RGBA_8888_EXACT_KHR 0x30C2 /* EGL_MATCH_FORMAT_KHR value */ +#define EGL_FORMAT_RGBA_8888_KHR 0x30C3 /* EGL_MATCH_FORMAT_KHR value */ +#define EGL_MAP_PRESERVE_PIXELS_KHR 0x30C4 /* eglLockSurfaceKHR attribute */ +#define EGL_LOCK_USAGE_HINT_KHR 0x30C5 /* eglLockSurfaceKHR attribute */ +#define EGL_BITMAP_POINTER_KHR 0x30C6 /* eglQuerySurface attribute */ +#define EGL_BITMAP_PITCH_KHR 0x30C7 /* eglQuerySurface attribute */ +#define EGL_BITMAP_ORIGIN_KHR 0x30C8 /* eglQuerySurface attribute */ +#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR 0x30C9 /* eglQuerySurface attribute */ +#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR 0x30CA /* eglQuerySurface attribute */ +#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR 0x30CB /* eglQuerySurface attribute */ +#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR 0x30CC /* eglQuerySurface attribute */ +#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR 0x30CD /* eglQuerySurface attribute */ +#define EGL_LOWER_LEFT_KHR 0x30CE /* EGL_BITMAP_ORIGIN_KHR value */ +#define EGL_UPPER_LEFT_KHR 0x30CF /* EGL_BITMAP_ORIGIN_KHR value */ +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list); +EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay display, EGLSurface surface); +#endif /* EGL_EGLEXT_PROTOTYPES */ +typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface); +#endif + +#ifndef EGL_KHR_image +#define EGL_KHR_image 1 +#define EGL_NATIVE_PIXMAP_KHR 0x30B0 /* eglCreateImageKHR target */ +typedef void *EGLImageKHR; +#define EGL_NO_IMAGE_KHR ((EGLImageKHR)0) +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list); +EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image); +#endif /* EGL_EGLEXT_PROTOTYPES */ +typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image); +#endif + +#ifndef EGL_KHR_vg_parent_image +#define EGL_KHR_vg_parent_image 1 +#define EGL_VG_PARENT_IMAGE_KHR 0x30BA /* eglCreateImageKHR target */ +#endif + +#ifndef EGL_KHR_gl_texture_2D_image +#define EGL_KHR_gl_texture_2D_image 1 +#define EGL_GL_TEXTURE_2D_KHR 0x30B1 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_LEVEL_KHR 0x30BC /* eglCreateImageKHR attribute */ +#endif + +#ifndef EGL_KHR_gl_texture_cubemap_image +#define EGL_KHR_gl_texture_cubemap_image 1 +#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR 0x30B3 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR 0x30B4 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR 0x30B5 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR 0x30B6 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR 0x30B7 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR 0x30B8 /* eglCreateImageKHR target */ +#endif + +#ifndef EGL_KHR_gl_texture_3D_image +#define EGL_KHR_gl_texture_3D_image 1 +#define EGL_GL_TEXTURE_3D_KHR 0x30B2 /* eglCreateImageKHR target */ +#define EGL_GL_TEXTURE_ZOFFSET_KHR 0x30BD /* eglCreateImageKHR attribute */ +#endif + +#ifndef EGL_KHR_gl_renderbuffer_image +#define EGL_KHR_gl_renderbuffer_image 1 +#define EGL_GL_RENDERBUFFER_KHR 0x30B9 /* eglCreateImageKHR target */ +#endif + +#ifndef EGL_KHR_reusable_sync +#define EGL_KHR_reusable_sync 1 + +typedef void* EGLSyncKHR; +typedef khronos_utime_nanoseconds_t EGLTimeKHR; + +#define EGL_SYNC_STATUS_KHR 0x30F1 +#define EGL_SIGNALED_KHR 0x30F2 +#define EGL_UNSIGNALED_KHR 0x30F3 +#define EGL_TIMEOUT_EXPIRED_KHR 0x30F5 +#define EGL_CONDITION_SATISFIED_KHR 0x30F6 +#define EGL_SYNC_TYPE_KHR 0x30F7 +#define EGL_SYNC_REUSABLE_KHR 0x30FA +#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001 /* eglClientWaitSyncKHR bitfield */ +#define EGL_FOREVER_KHR 0xFFFFFFFFFFFFFFFFull +#define EGL_NO_SYNC_KHR ((EGLSyncKHR)0) +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list); +EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync); +EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout); +EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode); +EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value); +#endif /* EGL_EGLEXT_PROTOTYPES */ +typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNCKHRPROC) (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync); +typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value); +#endif + +#ifndef EGL_KHR_image_base +#define EGL_KHR_image_base 1 +/* Most interfaces defined by EGL_KHR_image_pixmap above */ +#define EGL_IMAGE_PRESERVED_KHR 0x30D2 /* eglCreateImageKHR attribute */ +#endif + +#ifndef EGL_KHR_image_pixmap +#define EGL_KHR_image_pixmap 1 +/* Interfaces defined by EGL_KHR_image above */ +#endif + +#ifndef EGL_IMG_context_priority +#define EGL_IMG_context_priority 1 +#define EGL_CONTEXT_PRIORITY_LEVEL_IMG 0x3100 +#define EGL_CONTEXT_PRIORITY_HIGH_IMG 0x3101 +#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG 0x3102 +#define EGL_CONTEXT_PRIORITY_LOW_IMG 0x3103 +#endif + +#ifndef EGL_NV_coverage_sample +#define EGL_NV_coverage_sample 1 +#define EGL_COVERAGE_BUFFERS_NV 0x30E0 +#define EGL_COVERAGE_SAMPLES_NV 0x30E1 +#endif + +#ifndef EGL_NV_depth_nonlinear +#define EGL_NV_depth_nonlinear 1 +#define EGL_DEPTH_ENCODING_NV 0x30E2 +#define EGL_DEPTH_ENCODING_NONE_NV 0 +#define EGL_DEPTH_ENCODING_NONLINEAR_NV 0x30E3 +#endif + +#ifndef EGL_NV_sync +#define EGL_NV_sync 1 +#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV 0x30E6 +#define EGL_SYNC_STATUS_NV 0x30E7 +#define EGL_SIGNALED_NV 0x30E8 +#define EGL_UNSIGNALED_NV 0x30E9 +#define EGL_SYNC_FLUSH_COMMANDS_BIT_NV 0x0001 +#define EGL_FOREVER_NV 0xFFFFFFFFFFFFFFFFull +#define EGL_ALREADY_SIGNALED_NV 0x30EA +#define EGL_TIMEOUT_EXPIRED_NV 0x30EB +#define EGL_CONDITION_SATISFIED_NV 0x30EC +#define EGL_SYNC_TYPE_NV 0x30ED +#define EGL_SYNC_CONDITION_NV 0x30EE +#define EGL_SYNC_FENCE_NV 0x30EF +#define EGL_NO_SYNC_NV ((EGLSyncNV)0) +typedef void* EGLSyncNV; +typedef unsigned long long EGLTimeNV; +#ifdef EGL_EGLEXT_PROTOTYPES +EGLSyncNV eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list); +EGLBoolean eglDestroySyncNV (EGLSyncNV sync); +EGLBoolean eglFenceNV (EGLSyncNV sync); +EGLint eglClientWaitSyncNV (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout); +EGLBoolean eglSignalSyncNV (EGLSyncNV sync, EGLenum mode); +EGLBoolean eglGetSyncAttribNV (EGLSyncNV sync, EGLint attribute, EGLint *value); +#endif /* EGL_EGLEXT_PROTOTYPES */ +typedef EGLSyncNV (EGLAPIENTRYP PFNEGLCREATEFENCESYNCNVPROC) (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCNVPROC) (EGLSyncNV sync); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLFENCENVPROC) (EGLSyncNV sync); +typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCNVPROC) (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode); +typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value); +#endif + +#ifndef EGL_KHR_fence_sync +#define EGL_KHR_fence_sync 1 +/* Reuses most tokens and entry points from EGL_KHR_reusable_sync */ +#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR 0x30F0 +#define EGL_SYNC_CONDITION_KHR 0x30F8 +#define EGL_SYNC_FENCE_KHR 0x30F9 +#endif + +#ifndef EGL_ANDROID_image_native_buffer +#define EGL_ANDROID_image_native_buffer 1 +struct android_native_buffer_t; +#define EGL_NATIVE_BUFFER_ANDROID 0x3140 /* eglCreateImageKHR target */ +#endif + +#ifndef EGL_ANDROID_swap_rectangle +#define EGL_ANDROID_swap_rectangle 1 +#ifdef EGL_EGLEXT_PROTOTYPES +EGLAPI EGLBoolean EGLAPIENTRY eglSetSwapRectangleANDROID (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height); +#endif /* EGL_EGLEXT_PROTOTYPES */ +typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSWAPRECTANGLEANDROIDPROC) (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/include/EGL/eglplatform.h b/tools/emulator/opengl/host/libs/Translator/include/EGL/eglplatform.h new file mode 100644 index 000000000..8ee5634b2 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/EGL/eglplatform.h @@ -0,0 +1,109 @@ +#ifndef __eglplatform_h_ +#define __eglplatform_h_ +/* +** Copyright (c) 2007-2009 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Platform-specific types and definitions for egl.h + * $Revision: 9724 $ on $Date: 2009-12-02 02:05:33 -0800 (Wed, 02 Dec 2009) $ + * + * Adopters may modify khrplatform.h and this file to suit their platform. + * You are encouraged to submit all modifications to the Khronos group so that + * they can be included in future versions of this file. Please submit changes + * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla) + * by filing a bug against product "EGL" component "Registry". + */ +#include + +/* Macros used in EGL function prototype declarations. + * + * EGL functions should be prototyped as: + * + * EGLAPI return-type EGLAPIENTRY eglFunction(arguments); + * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments); + * + * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h + */ + +#ifndef EGLAPI +#define EGLAPI KHRONOS_APICALL +#endif + +#ifndef EGLAPIENTRY +#define EGLAPIENTRY KHRONOS_APIENTRY +#endif +#define EGLAPIENTRYP EGLAPIENTRY* + +/* The types NativeDisplayType, NativeWindowType, and NativePixmapType + * are aliases of window-system-dependent types, such as X Display * or + * Windows Device Context. They must be defined in platform-specific + * code below. The EGL-prefixed versions of Native*Type are the same + * types, renamed in EGL 1.3 so all types in the API start with "EGL". + */ + +#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */ +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN 1 +#endif +#include + +typedef PIXELFORMATDESCRIPTOR EGLNativePixelFormatType; +typedef HGLRC EGLNativeContextType; +typedef HPBUFFERARB EGLNativePbufferType; +typedef HDC EGLNativeDisplayType; +typedef HBITMAP EGLNativePixmapType; +typedef HWND EGLNativeWindowType; + +#elif defined(__unix__) + +/* X11 (tentative) */ +#include +#include +#include + +typedef GLXFBConfig EGLNativePixelFormatType; +typedef GLXContext EGLNativeContextType; +typedef GLXPbuffer EGLNativePbufferType; +typedef Display * EGLNativeDisplayType; +typedef Pixmap EGLNativePixmapType; +typedef Window EGLNativeWindowType; + +#else +#error "Platform not recognized" +#endif + +/* EGL 1.2 types, renamed for consistency in EGL 1.3 */ +typedef EGLNativeDisplayType NativeDisplayType; +typedef EGLNativePixmapType NativePixmapType; +typedef EGLNativeWindowType NativeWindowType; + + +/* Define EGLint. This must be a signed integral type large enough to contain + * all legal attribute names and values passed into and out of EGL, whether + * their type is boolean, bitmask, enumerant (symbolic constant), integer, + * handle, or other. While in general a 32-bit integer will suffice, if + * handles are 64 bit types, then EGLint should be defined as a signed 64-bit + * integer type. + */ +typedef khronos_int32_t EGLint; + +#endif /* __eglplatform_h */