370 lines
12 KiB
C++
370 lines
12 KiB
C++
/*
|
|
* 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 <ui/FramebufferNativeWindow.h>
|
|
#include <ui/PixelFormat.h>
|
|
#include <ui/EGLUtils.h>
|
|
#include <ui/egl/android_natives.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/resource.h>
|
|
#include <sched.h>
|
|
|
|
#include <cutils/properties.h>
|
|
|
|
#include <GLES/gl.h>
|
|
#include <GLES/glext.h>
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "rsdCore.h"
|
|
#include "rsdGL.h"
|
|
|
|
#include <malloc.h>
|
|
#include "rsContext.h"
|
|
#include "rsdShaderCache.h"
|
|
#include "rsdVertexArray.h"
|
|
|
|
using namespace android;
|
|
using namespace android::renderscript;
|
|
|
|
static int32_t gGLContextCount = 0;
|
|
|
|
static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) {
|
|
if (returnVal != EGL_TRUE) {
|
|
fprintf(stderr, "%s() returned %d\n", op, returnVal);
|
|
}
|
|
|
|
for (EGLint error = eglGetError(); error != EGL_SUCCESS; error
|
|
= eglGetError()) {
|
|
fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error),
|
|
error);
|
|
}
|
|
}
|
|
|
|
static void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) {
|
|
|
|
#define X(VAL) {VAL, #VAL}
|
|
struct {EGLint attribute; const char* name;} names[] = {
|
|
X(EGL_BUFFER_SIZE),
|
|
X(EGL_ALPHA_SIZE),
|
|
X(EGL_BLUE_SIZE),
|
|
X(EGL_GREEN_SIZE),
|
|
X(EGL_RED_SIZE),
|
|
X(EGL_DEPTH_SIZE),
|
|
X(EGL_STENCIL_SIZE),
|
|
X(EGL_CONFIG_CAVEAT),
|
|
X(EGL_CONFIG_ID),
|
|
X(EGL_LEVEL),
|
|
X(EGL_MAX_PBUFFER_HEIGHT),
|
|
X(EGL_MAX_PBUFFER_PIXELS),
|
|
X(EGL_MAX_PBUFFER_WIDTH),
|
|
X(EGL_NATIVE_RENDERABLE),
|
|
X(EGL_NATIVE_VISUAL_ID),
|
|
X(EGL_NATIVE_VISUAL_TYPE),
|
|
X(EGL_SAMPLES),
|
|
X(EGL_SAMPLE_BUFFERS),
|
|
X(EGL_SURFACE_TYPE),
|
|
X(EGL_TRANSPARENT_TYPE),
|
|
X(EGL_TRANSPARENT_RED_VALUE),
|
|
X(EGL_TRANSPARENT_GREEN_VALUE),
|
|
X(EGL_TRANSPARENT_BLUE_VALUE),
|
|
X(EGL_BIND_TO_TEXTURE_RGB),
|
|
X(EGL_BIND_TO_TEXTURE_RGBA),
|
|
X(EGL_MIN_SWAP_INTERVAL),
|
|
X(EGL_MAX_SWAP_INTERVAL),
|
|
X(EGL_LUMINANCE_SIZE),
|
|
X(EGL_ALPHA_MASK_SIZE),
|
|
X(EGL_COLOR_BUFFER_TYPE),
|
|
X(EGL_RENDERABLE_TYPE),
|
|
X(EGL_CONFORMANT),
|
|
};
|
|
#undef X
|
|
|
|
for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) {
|
|
EGLint value = -1;
|
|
EGLint returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value);
|
|
EGLint error = eglGetError();
|
|
if (returnVal && error == EGL_SUCCESS) {
|
|
LOGV(" %s: %d (0x%x)", names[j].name, value, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void DumpDebug(RsdHal *dc) {
|
|
LOGE(" EGL ver %i %i", dc->gl.egl.majorVersion, dc->gl.egl.minorVersion);
|
|
LOGE(" EGL context %p surface %p, Display=%p", dc->gl.egl.context, dc->gl.egl.surface,
|
|
dc->gl.egl.display);
|
|
LOGE(" GL vendor: %s", dc->gl.gl.vendor);
|
|
LOGE(" GL renderer: %s", dc->gl.gl.renderer);
|
|
LOGE(" GL Version: %s", dc->gl.gl.version);
|
|
LOGE(" GL Extensions: %s", dc->gl.gl.extensions);
|
|
LOGE(" GL int Versions %i %i", dc->gl.gl.majorVersion, dc->gl.gl.minorVersion);
|
|
|
|
LOGV("MAX Textures %i, %i %i", dc->gl.gl.maxVertexTextureUnits,
|
|
dc->gl.gl.maxFragmentTextureImageUnits, dc->gl.gl.maxTextureImageUnits);
|
|
LOGV("MAX Attribs %i", dc->gl.gl.maxVertexAttribs);
|
|
LOGV("MAX Uniforms %i, %i", dc->gl.gl.maxVertexUniformVectors,
|
|
dc->gl.gl.maxFragmentUniformVectors);
|
|
LOGV("MAX Varyings %i", dc->gl.gl.maxVaryingVectors);
|
|
}
|
|
|
|
void rsdGLShutdown(const Context *rsc) {
|
|
RsdHal *dc = (RsdHal *)rsc->mHal.drv;
|
|
|
|
dc->gl.shaderCache->cleanupAll();
|
|
delete dc->gl.shaderCache;
|
|
|
|
delete dc->gl.vertexArrayState;
|
|
|
|
LOGV("%p, deinitEGL", rsc);
|
|
|
|
if (dc->gl.egl.context != EGL_NO_CONTEXT) {
|
|
eglMakeCurrent(dc->gl.egl.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
|
|
eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surfaceDefault);
|
|
if (dc->gl.egl.surface != EGL_NO_SURFACE) {
|
|
eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surface);
|
|
}
|
|
eglDestroyContext(dc->gl.egl.display, dc->gl.egl.context);
|
|
checkEglError("eglDestroyContext");
|
|
}
|
|
|
|
gGLContextCount--;
|
|
if (!gGLContextCount) {
|
|
eglTerminate(dc->gl.egl.display);
|
|
}
|
|
}
|
|
|
|
bool rsdGLInit(const Context *rsc) {
|
|
RsdHal *dc = (RsdHal *)rsc->mHal.drv;
|
|
|
|
dc->gl.egl.numConfigs = -1;
|
|
EGLint configAttribs[128];
|
|
EGLint *configAttribsPtr = configAttribs;
|
|
EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
|
|
|
|
memset(configAttribs, 0, sizeof(configAttribs));
|
|
|
|
configAttribsPtr[0] = EGL_SURFACE_TYPE;
|
|
configAttribsPtr[1] = EGL_WINDOW_BIT;
|
|
configAttribsPtr += 2;
|
|
|
|
configAttribsPtr[0] = EGL_RENDERABLE_TYPE;
|
|
configAttribsPtr[1] = EGL_OPENGL_ES2_BIT;
|
|
configAttribsPtr += 2;
|
|
|
|
if (rsc->mUserSurfaceConfig.depthMin > 0) {
|
|
configAttribsPtr[0] = EGL_DEPTH_SIZE;
|
|
configAttribsPtr[1] = rsc->mUserSurfaceConfig.depthMin;
|
|
configAttribsPtr += 2;
|
|
}
|
|
|
|
if (rsc->mDev->mForceSW) {
|
|
configAttribsPtr[0] = EGL_CONFIG_CAVEAT;
|
|
configAttribsPtr[1] = EGL_SLOW_CONFIG;
|
|
configAttribsPtr += 2;
|
|
}
|
|
|
|
configAttribsPtr[0] = EGL_NONE;
|
|
rsAssert(configAttribsPtr < (configAttribs + (sizeof(configAttribs) / sizeof(EGLint))));
|
|
|
|
LOGV("%p initEGL start", rsc);
|
|
dc->gl.egl.display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
checkEglError("eglGetDisplay");
|
|
|
|
eglInitialize(dc->gl.egl.display, &dc->gl.egl.majorVersion, &dc->gl.egl.minorVersion);
|
|
checkEglError("eglInitialize");
|
|
|
|
PixelFormat pf = PIXEL_FORMAT_RGBA_8888;
|
|
if (rsc->mUserSurfaceConfig.alphaMin == 0) {
|
|
pf = PIXEL_FORMAT_RGBX_8888;
|
|
}
|
|
|
|
status_t err = EGLUtils::selectConfigForPixelFormat(dc->gl.egl.display, configAttribs,
|
|
pf, &dc->gl.egl.config);
|
|
if (err) {
|
|
LOGE("%p, couldn't find an EGLConfig matching the screen format\n", rsc);
|
|
}
|
|
//if (props.mLogVisual) {
|
|
if (0) {
|
|
printEGLConfiguration(dc->gl.egl.display, dc->gl.egl.config);
|
|
}
|
|
//}
|
|
|
|
dc->gl.egl.context = eglCreateContext(dc->gl.egl.display, dc->gl.egl.config,
|
|
EGL_NO_CONTEXT, context_attribs2);
|
|
checkEglError("eglCreateContext");
|
|
if (dc->gl.egl.context == EGL_NO_CONTEXT) {
|
|
LOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", rsc);
|
|
return false;
|
|
}
|
|
gGLContextCount++;
|
|
|
|
|
|
EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
|
|
dc->gl.egl.surfaceDefault = eglCreatePbufferSurface(dc->gl.egl.display, dc->gl.egl.config,
|
|
pbuffer_attribs);
|
|
checkEglError("eglCreatePbufferSurface");
|
|
if (dc->gl.egl.surfaceDefault == EGL_NO_SURFACE) {
|
|
LOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE");
|
|
rsdGLShutdown(rsc);
|
|
return false;
|
|
}
|
|
|
|
EGLBoolean ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault,
|
|
dc->gl.egl.surfaceDefault, dc->gl.egl.context);
|
|
if (ret == EGL_FALSE) {
|
|
LOGE("eglMakeCurrent returned EGL_FALSE");
|
|
checkEglError("eglMakeCurrent", ret);
|
|
rsdGLShutdown(rsc);
|
|
return false;
|
|
}
|
|
|
|
dc->gl.gl.version = glGetString(GL_VERSION);
|
|
dc->gl.gl.vendor = glGetString(GL_VENDOR);
|
|
dc->gl.gl.renderer = glGetString(GL_RENDERER);
|
|
dc->gl.gl.extensions = glGetString(GL_EXTENSIONS);
|
|
|
|
//LOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
|
|
//LOGV("GL Version %s", mGL.mVersion);
|
|
//LOGV("GL Vendor %s", mGL.mVendor);
|
|
//LOGV("GL Renderer %s", mGL.mRenderer);
|
|
//LOGV("GL Extensions %s", mGL.mExtensions);
|
|
|
|
const char *verptr = NULL;
|
|
if (strlen((const char *)dc->gl.gl.version) > 9) {
|
|
if (!memcmp(dc->gl.gl.version, "OpenGL ES-CM", 12)) {
|
|
verptr = (const char *)dc->gl.gl.version + 12;
|
|
}
|
|
if (!memcmp(dc->gl.gl.version, "OpenGL ES ", 10)) {
|
|
verptr = (const char *)dc->gl.gl.version + 9;
|
|
}
|
|
}
|
|
|
|
if (!verptr) {
|
|
LOGE("Error, OpenGL ES Lite not supported");
|
|
rsdGLShutdown(rsc);
|
|
return false;
|
|
} else {
|
|
sscanf(verptr, " %i.%i", &dc->gl.gl.majorVersion, &dc->gl.gl.minorVersion);
|
|
}
|
|
|
|
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &dc->gl.gl.maxVertexAttribs);
|
|
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &dc->gl.gl.maxVertexUniformVectors);
|
|
glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxVertexTextureUnits);
|
|
|
|
glGetIntegerv(GL_MAX_VARYING_VECTORS, &dc->gl.gl.maxVaryingVectors);
|
|
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxTextureImageUnits);
|
|
|
|
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxFragmentTextureImageUnits);
|
|
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &dc->gl.gl.maxFragmentUniformVectors);
|
|
|
|
dc->gl.gl.OES_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions,
|
|
"GL_OES_texture_npot");
|
|
dc->gl.gl.GL_IMG_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions,
|
|
"GL_IMG_texture_npot");
|
|
dc->gl.gl.GL_NV_texture_npot_2D_mipmap = NULL != strstr((const char *)dc->gl.gl.extensions,
|
|
"GL_NV_texture_npot_2D_mipmap");
|
|
dc->gl.gl.EXT_texture_max_aniso = 1.0f;
|
|
bool hasAniso = NULL != strstr((const char *)dc->gl.gl.extensions,
|
|
"GL_EXT_texture_filter_anisotropic");
|
|
if (hasAniso) {
|
|
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &dc->gl.gl.EXT_texture_max_aniso);
|
|
}
|
|
|
|
if (0) {
|
|
DumpDebug(dc);
|
|
}
|
|
|
|
dc->gl.shaderCache = new RsdShaderCache();
|
|
dc->gl.vertexArrayState = new RsdVertexArrayState();
|
|
dc->gl.vertexArrayState->init(dc->gl.gl.maxVertexAttribs);
|
|
|
|
LOGV("initGLThread end %p", rsc);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool rsdGLSetSurface(const Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) {
|
|
RsdHal *dc = (RsdHal *)rsc->mHal.drv;
|
|
|
|
EGLBoolean ret;
|
|
// WAR: Some drivers fail to handle 0 size surfaces correcntly.
|
|
// Use the pbuffer to avoid this pitfall.
|
|
if ((dc->gl.egl.surface != NULL) || (w == 0) || (h == 0)) {
|
|
ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault,
|
|
dc->gl.egl.surfaceDefault, dc->gl.egl.context);
|
|
checkEglError("eglMakeCurrent", ret);
|
|
|
|
ret = eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surface);
|
|
checkEglError("eglDestroySurface", ret);
|
|
|
|
dc->gl.egl.surface = NULL;
|
|
dc->gl.width = 1;
|
|
dc->gl.height = 1;
|
|
}
|
|
|
|
dc->gl.wndSurface = (ANativeWindow *)sur;
|
|
if (dc->gl.wndSurface != NULL) {
|
|
dc->gl.width = w;
|
|
dc->gl.height = h;
|
|
|
|
dc->gl.egl.surface = eglCreateWindowSurface(dc->gl.egl.display, dc->gl.egl.config,
|
|
dc->gl.wndSurface, NULL);
|
|
checkEglError("eglCreateWindowSurface");
|
|
if (dc->gl.egl.surface == EGL_NO_SURFACE) {
|
|
LOGE("eglCreateWindowSurface returned EGL_NO_SURFACE");
|
|
}
|
|
|
|
ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surface,
|
|
dc->gl.egl.surface, dc->gl.egl.context);
|
|
checkEglError("eglMakeCurrent", ret);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void rsdGLSwap(const android::renderscript::Context *rsc) {
|
|
RsdHal *dc = (RsdHal *)rsc->mHal.drv;
|
|
eglSwapBuffers(dc->gl.egl.display, dc->gl.egl.surface);
|
|
}
|
|
|
|
void rsdGLCheckError(const android::renderscript::Context *rsc,
|
|
const char *msg, bool isFatal) {
|
|
GLenum err = glGetError();
|
|
if (err != GL_NO_ERROR) {
|
|
char buf[1024];
|
|
snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg);
|
|
|
|
if (isFatal) {
|
|
rsc->setError(RS_ERROR_FATAL_DRIVER, buf);
|
|
} else {
|
|
switch (err) {
|
|
case GL_OUT_OF_MEMORY:
|
|
rsc->setError(RS_ERROR_OUT_OF_MEMORY, buf);
|
|
break;
|
|
default:
|
|
rsc->setError(RS_ERROR_DRIVER, buf);
|
|
break;
|
|
}
|
|
}
|
|
|
|
LOGE("%p, %s", rsc, buf);
|
|
}
|
|
|
|
}
|