Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include <ui/FramebufferNativeWindow.h> |
| 18 | #include <ui/PixelFormat.h> |
Mathias Agopian | b8eba19 | 2012-02-24 18:25:41 -0800 | [diff] [blame] | 19 | |
| 20 | #include <system/window.h> |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 21 | |
| 22 | #include <sys/types.h> |
| 23 | #include <sys/resource.h> |
| 24 | #include <sched.h> |
| 25 | |
| 26 | #include <cutils/properties.h> |
| 27 | |
| 28 | #include <GLES/gl.h> |
| 29 | #include <GLES/glext.h> |
| 30 | #include <GLES2/gl2.h> |
| 31 | #include <GLES2/gl2ext.h> |
| 32 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 33 | #include <string.h> |
| 34 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 35 | #include "rsdCore.h" |
| 36 | #include "rsdGL.h" |
| 37 | |
| 38 | #include <malloc.h> |
| 39 | #include "rsContext.h" |
Alex Sakhartchouk | 4edf030 | 2012-03-09 10:47:27 -0800 | [diff] [blame] | 40 | #include "rsDevice.h" |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 41 | #include "rsdShaderCache.h" |
| 42 | #include "rsdVertexArray.h" |
Alex Sakhartchouk | a949524 | 2011-06-16 11:05:13 -0700 | [diff] [blame] | 43 | #include "rsdFrameBufferObj.h" |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 44 | |
Mathias Agopian | 33c622e | 2013-02-14 17:34:06 -0800 | [diff] [blame] | 45 | #include <gui/Surface.h> |
Alex Sakhartchouk | 5575cf1 | 2012-02-28 10:16:06 -0800 | [diff] [blame] | 46 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 47 | using namespace android; |
| 48 | using namespace android::renderscript; |
| 49 | |
| 50 | static int32_t gGLContextCount = 0; |
| 51 | |
| 52 | static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { |
Mathias Agopian | e255929 | 2012-02-24 16:42:46 -0800 | [diff] [blame] | 53 | struct EGLUtils { |
| 54 | static const char *strerror(EGLint err) { |
| 55 | switch (err){ |
| 56 | case EGL_SUCCESS: return "EGL_SUCCESS"; |
| 57 | case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED"; |
| 58 | case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS"; |
| 59 | case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC"; |
| 60 | case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE"; |
| 61 | case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG"; |
| 62 | case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT"; |
| 63 | case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE"; |
| 64 | case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY"; |
| 65 | case EGL_BAD_MATCH: return "EGL_BAD_MATCH"; |
| 66 | case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP"; |
| 67 | case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW"; |
| 68 | case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER"; |
| 69 | case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE"; |
| 70 | case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST"; |
| 71 | default: return "UNKNOWN"; |
| 72 | } |
| 73 | } |
| 74 | }; |
| 75 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 76 | if (returnVal != EGL_TRUE) { |
| 77 | fprintf(stderr, "%s() returned %d\n", op, returnVal); |
| 78 | } |
| 79 | |
| 80 | for (EGLint error = eglGetError(); error != EGL_SUCCESS; error |
| 81 | = eglGetError()) { |
| 82 | fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error), |
| 83 | error); |
| 84 | } |
| 85 | } |
| 86 | |
| 87 | static void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) { |
| 88 | |
| 89 | #define X(VAL) {VAL, #VAL} |
| 90 | struct {EGLint attribute; const char* name;} names[] = { |
| 91 | X(EGL_BUFFER_SIZE), |
| 92 | X(EGL_ALPHA_SIZE), |
| 93 | X(EGL_BLUE_SIZE), |
| 94 | X(EGL_GREEN_SIZE), |
| 95 | X(EGL_RED_SIZE), |
| 96 | X(EGL_DEPTH_SIZE), |
| 97 | X(EGL_STENCIL_SIZE), |
| 98 | X(EGL_CONFIG_CAVEAT), |
| 99 | X(EGL_CONFIG_ID), |
| 100 | X(EGL_LEVEL), |
| 101 | X(EGL_MAX_PBUFFER_HEIGHT), |
| 102 | X(EGL_MAX_PBUFFER_PIXELS), |
| 103 | X(EGL_MAX_PBUFFER_WIDTH), |
| 104 | X(EGL_NATIVE_RENDERABLE), |
| 105 | X(EGL_NATIVE_VISUAL_ID), |
| 106 | X(EGL_NATIVE_VISUAL_TYPE), |
| 107 | X(EGL_SAMPLES), |
| 108 | X(EGL_SAMPLE_BUFFERS), |
| 109 | X(EGL_SURFACE_TYPE), |
| 110 | X(EGL_TRANSPARENT_TYPE), |
| 111 | X(EGL_TRANSPARENT_RED_VALUE), |
| 112 | X(EGL_TRANSPARENT_GREEN_VALUE), |
| 113 | X(EGL_TRANSPARENT_BLUE_VALUE), |
| 114 | X(EGL_BIND_TO_TEXTURE_RGB), |
| 115 | X(EGL_BIND_TO_TEXTURE_RGBA), |
| 116 | X(EGL_MIN_SWAP_INTERVAL), |
| 117 | X(EGL_MAX_SWAP_INTERVAL), |
| 118 | X(EGL_LUMINANCE_SIZE), |
| 119 | X(EGL_ALPHA_MASK_SIZE), |
| 120 | X(EGL_COLOR_BUFFER_TYPE), |
| 121 | X(EGL_RENDERABLE_TYPE), |
| 122 | X(EGL_CONFORMANT), |
| 123 | }; |
| 124 | #undef X |
| 125 | |
| 126 | for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) { |
| 127 | EGLint value = -1; |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 128 | EGLBoolean returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value); |
| 129 | if (returnVal) { |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 130 | ALOGV(" %s: %d (0x%x)", names[j].name, value, value); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 131 | } |
| 132 | } |
| 133 | } |
| 134 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 135 | static void DumpDebug(RsdHal *dc) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 136 | ALOGE(" EGL ver %i %i", dc->gl.egl.majorVersion, dc->gl.egl.minorVersion); |
| 137 | ALOGE(" EGL context %p surface %p, Display=%p", dc->gl.egl.context, dc->gl.egl.surface, |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 138 | dc->gl.egl.display); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 139 | ALOGE(" GL vendor: %s", dc->gl.gl.vendor); |
| 140 | ALOGE(" GL renderer: %s", dc->gl.gl.renderer); |
| 141 | ALOGE(" GL Version: %s", dc->gl.gl.version); |
| 142 | ALOGE(" GL Extensions: %s", dc->gl.gl.extensions); |
| 143 | ALOGE(" GL int Versions %i %i", dc->gl.gl.majorVersion, dc->gl.gl.minorVersion); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 144 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 145 | ALOGV("MAX Textures %i, %i %i", dc->gl.gl.maxVertexTextureUnits, |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 146 | dc->gl.gl.maxFragmentTextureImageUnits, dc->gl.gl.maxTextureImageUnits); |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 147 | ALOGV("MAX Attribs %i", dc->gl.gl.maxVertexAttribs); |
| 148 | ALOGV("MAX Uniforms %i, %i", dc->gl.gl.maxVertexUniformVectors, |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 149 | dc->gl.gl.maxFragmentUniformVectors); |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 150 | ALOGV("MAX Varyings %i", dc->gl.gl.maxVaryingVectors); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | void rsdGLShutdown(const Context *rsc) { |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 154 | RsdHal *dc = (RsdHal *)rsc->mHal.drv; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 155 | |
Jason Sams | 1d89243 | 2012-05-08 13:12:46 -0700 | [diff] [blame] | 156 | rsdGLSetSurface(rsc, 0, 0, NULL); |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 157 | dc->gl.shaderCache->cleanupAll(); |
| 158 | delete dc->gl.shaderCache; |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 159 | delete dc->gl.vertexArrayState; |
| 160 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 161 | if (dc->gl.egl.context != EGL_NO_CONTEXT) { |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 162 | RSD_CALL_GL(eglMakeCurrent, dc->gl.egl.display, |
| 163 | EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); |
| 164 | RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surfaceDefault); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 165 | if (dc->gl.egl.surface != EGL_NO_SURFACE) { |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 166 | RSD_CALL_GL(eglDestroySurface, dc->gl.egl.display, dc->gl.egl.surface); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 167 | } |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 168 | RSD_CALL_GL(eglDestroyContext, dc->gl.egl.display, dc->gl.egl.context); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 169 | checkEglError("eglDestroyContext"); |
| 170 | } |
| 171 | |
| 172 | gGLContextCount--; |
| 173 | if (!gGLContextCount) { |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 174 | RSD_CALL_GL(eglTerminate, dc->gl.egl.display); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 175 | } |
| 176 | } |
| 177 | |
Alex Sakhartchouk | da7a148 | 2012-02-28 14:35:31 -0800 | [diff] [blame] | 178 | void getConfigData(const Context *rsc, |
| 179 | EGLint *configAttribs, size_t configAttribsLen, |
| 180 | uint32_t numSamples) { |
| 181 | memset(configAttribs, 0, configAttribsLen*sizeof(*configAttribs)); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 182 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 183 | EGLint *configAttribsPtr = configAttribs; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 184 | |
| 185 | configAttribsPtr[0] = EGL_SURFACE_TYPE; |
| 186 | configAttribsPtr[1] = EGL_WINDOW_BIT; |
| 187 | configAttribsPtr += 2; |
| 188 | |
| 189 | configAttribsPtr[0] = EGL_RENDERABLE_TYPE; |
| 190 | configAttribsPtr[1] = EGL_OPENGL_ES2_BIT; |
| 191 | configAttribsPtr += 2; |
| 192 | |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 193 | configAttribsPtr[0] = EGL_RED_SIZE; |
| 194 | configAttribsPtr[1] = 8; |
| 195 | configAttribsPtr += 2; |
| 196 | |
| 197 | configAttribsPtr[0] = EGL_GREEN_SIZE; |
| 198 | configAttribsPtr[1] = 8; |
| 199 | configAttribsPtr += 2; |
| 200 | |
| 201 | configAttribsPtr[0] = EGL_BLUE_SIZE; |
| 202 | configAttribsPtr[1] = 8; |
| 203 | configAttribsPtr += 2; |
| 204 | |
| 205 | if (rsc->mUserSurfaceConfig.alphaMin > 0) { |
| 206 | configAttribsPtr[0] = EGL_ALPHA_SIZE; |
| 207 | configAttribsPtr[1] = rsc->mUserSurfaceConfig.alphaMin; |
| 208 | configAttribsPtr += 2; |
| 209 | } |
| 210 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 211 | if (rsc->mUserSurfaceConfig.depthMin > 0) { |
| 212 | configAttribsPtr[0] = EGL_DEPTH_SIZE; |
| 213 | configAttribsPtr[1] = rsc->mUserSurfaceConfig.depthMin; |
| 214 | configAttribsPtr += 2; |
| 215 | } |
| 216 | |
| 217 | if (rsc->mDev->mForceSW) { |
| 218 | configAttribsPtr[0] = EGL_CONFIG_CAVEAT; |
| 219 | configAttribsPtr[1] = EGL_SLOW_CONFIG; |
| 220 | configAttribsPtr += 2; |
| 221 | } |
| 222 | |
Alex Sakhartchouk | da7a148 | 2012-02-28 14:35:31 -0800 | [diff] [blame] | 223 | if (numSamples > 1) { |
| 224 | configAttribsPtr[0] = EGL_SAMPLE_BUFFERS; |
| 225 | configAttribsPtr[1] = 1; |
| 226 | configAttribsPtr[2] = EGL_SAMPLES; |
| 227 | configAttribsPtr[3] = numSamples; |
| 228 | configAttribsPtr += 4; |
| 229 | } |
| 230 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 231 | configAttribsPtr[0] = EGL_NONE; |
Alex Sakhartchouk | da7a148 | 2012-02-28 14:35:31 -0800 | [diff] [blame] | 232 | rsAssert(configAttribsPtr < (configAttribs + configAttribsLen)); |
| 233 | } |
| 234 | |
| 235 | bool rsdGLInit(const Context *rsc) { |
| 236 | RsdHal *dc = (RsdHal *)rsc->mHal.drv; |
| 237 | |
| 238 | dc->gl.egl.numConfigs = -1; |
| 239 | |
| 240 | EGLint configAttribs[128]; |
| 241 | EGLint context_attribs2[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 242 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 243 | ALOGV("%p initEGL start", rsc); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 244 | rsc->setWatchdogGL("eglGetDisplay", __LINE__, __FILE__); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 245 | dc->gl.egl.display = eglGetDisplay(EGL_DEFAULT_DISPLAY); |
| 246 | checkEglError("eglGetDisplay"); |
| 247 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 248 | RSD_CALL_GL(eglInitialize, dc->gl.egl.display, |
| 249 | &dc->gl.egl.majorVersion, &dc->gl.egl.minorVersion); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 250 | checkEglError("eglInitialize"); |
| 251 | |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 252 | EGLBoolean ret; |
| 253 | |
| 254 | EGLint numConfigs = -1, n = 0; |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 255 | rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__); |
Alex Sakhartchouk | da7a148 | 2012-02-28 14:35:31 -0800 | [diff] [blame] | 256 | |
| 257 | // Try minding a multisample config that matches the user request |
| 258 | uint32_t minSample = rsc->mUserSurfaceConfig.samplesMin; |
| 259 | uint32_t prefSample = rsc->mUserSurfaceConfig.samplesPref; |
| 260 | for (uint32_t sampleCount = prefSample; sampleCount >= minSample; sampleCount--) { |
| 261 | getConfigData(rsc, configAttribs, (sizeof(configAttribs) / sizeof(EGLint)), sampleCount); |
| 262 | ret = eglChooseConfig(dc->gl.egl.display, configAttribs, 0, 0, &numConfigs); |
| 263 | checkEglError("eglGetConfigs", ret); |
| 264 | if (numConfigs > 0) { |
| 265 | break; |
| 266 | } |
| 267 | } |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 268 | |
| 269 | if (numConfigs) { |
| 270 | EGLConfig* const configs = new EGLConfig[numConfigs]; |
| 271 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 272 | rsc->setWatchdogGL("eglChooseConfig", __LINE__, __FILE__); |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 273 | ret = eglChooseConfig(dc->gl.egl.display, |
| 274 | configAttribs, configs, numConfigs, &n); |
| 275 | if (!ret || !n) { |
| 276 | checkEglError("eglChooseConfig", ret); |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 277 | ALOGE("%p, couldn't find an EGLConfig matching the screen format\n", rsc); |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | // The first config is guaranteed to over-satisfy the constraints |
| 281 | dc->gl.egl.config = configs[0]; |
| 282 | |
| 283 | // go through the list and skip configs that over-satisfy our needs |
| 284 | for (int i=0 ; i<n ; i++) { |
| 285 | if (rsc->mUserSurfaceConfig.alphaMin <= 0) { |
| 286 | EGLint alphaSize; |
| 287 | eglGetConfigAttrib(dc->gl.egl.display, |
| 288 | configs[i], EGL_ALPHA_SIZE, &alphaSize); |
| 289 | if (alphaSize > 0) { |
| 290 | continue; |
| 291 | } |
| 292 | } |
| 293 | |
| 294 | if (rsc->mUserSurfaceConfig.depthMin <= 0) { |
| 295 | EGLint depthSize; |
| 296 | eglGetConfigAttrib(dc->gl.egl.display, |
| 297 | configs[i], EGL_DEPTH_SIZE, &depthSize); |
| 298 | if (depthSize > 0) { |
| 299 | continue; |
| 300 | } |
| 301 | } |
| 302 | |
| 303 | // Found one! |
| 304 | dc->gl.egl.config = configs[i]; |
| 305 | break; |
| 306 | } |
| 307 | |
| 308 | delete [] configs; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 309 | } |
| 310 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 311 | //if (props.mLogVisual) { |
Stephen Hines | 9db7fe2 | 2011-04-20 17:08:14 -0700 | [diff] [blame] | 312 | if (0) { |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 313 | printEGLConfiguration(dc->gl.egl.display, dc->gl.egl.config); |
Stephen Hines | 9db7fe2 | 2011-04-20 17:08:14 -0700 | [diff] [blame] | 314 | } |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 315 | //} |
| 316 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 317 | rsc->setWatchdogGL("eglCreateContext", __LINE__, __FILE__); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 318 | dc->gl.egl.context = eglCreateContext(dc->gl.egl.display, dc->gl.egl.config, |
| 319 | EGL_NO_CONTEXT, context_attribs2); |
| 320 | checkEglError("eglCreateContext"); |
| 321 | if (dc->gl.egl.context == EGL_NO_CONTEXT) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 322 | ALOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", rsc); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 323 | rsc->setWatchdogGL(NULL, 0, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 324 | return false; |
| 325 | } |
| 326 | gGLContextCount++; |
| 327 | |
Mathias Agopian | 3318d18 | 2013-07-16 22:56:00 -0700 | [diff] [blame] | 328 | EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE }; |
| 329 | rsc->setWatchdogGL("eglCreatePbufferSurface", __LINE__, __FILE__); |
| 330 | dc->gl.egl.surfaceDefault = eglCreatePbufferSurface(dc->gl.egl.display, dc->gl.egl.config, |
| 331 | pbuffer_attribs); |
| 332 | checkEglError("eglCreatePbufferSurface"); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 333 | if (dc->gl.egl.surfaceDefault == EGL_NO_SURFACE) { |
Mathias Agopian | 3318d18 | 2013-07-16 22:56:00 -0700 | [diff] [blame] | 334 | ALOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE"); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 335 | rsdGLShutdown(rsc); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 336 | rsc->setWatchdogGL(NULL, 0, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 337 | return false; |
| 338 | } |
| 339 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 340 | rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__); |
Mathias Agopian | 67605d7 | 2011-07-06 16:35:30 -0700 | [diff] [blame] | 341 | ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault, |
| 342 | dc->gl.egl.surfaceDefault, dc->gl.egl.context); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 343 | if (ret == EGL_FALSE) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 344 | ALOGE("eglMakeCurrent returned EGL_FALSE"); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 345 | checkEglError("eglMakeCurrent", ret); |
| 346 | rsdGLShutdown(rsc); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 347 | rsc->setWatchdogGL(NULL, 0, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 348 | return false; |
| 349 | } |
| 350 | |
| 351 | dc->gl.gl.version = glGetString(GL_VERSION); |
| 352 | dc->gl.gl.vendor = glGetString(GL_VENDOR); |
| 353 | dc->gl.gl.renderer = glGetString(GL_RENDERER); |
| 354 | dc->gl.gl.extensions = glGetString(GL_EXTENSIONS); |
| 355 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 356 | //ALOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion); |
| 357 | //ALOGV("GL Version %s", mGL.mVersion); |
| 358 | //ALOGV("GL Vendor %s", mGL.mVendor); |
| 359 | //ALOGV("GL Renderer %s", mGL.mRenderer); |
| 360 | //ALOGV("GL Extensions %s", mGL.mExtensions); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 361 | |
| 362 | const char *verptr = NULL; |
| 363 | if (strlen((const char *)dc->gl.gl.version) > 9) { |
| 364 | if (!memcmp(dc->gl.gl.version, "OpenGL ES-CM", 12)) { |
| 365 | verptr = (const char *)dc->gl.gl.version + 12; |
| 366 | } |
| 367 | if (!memcmp(dc->gl.gl.version, "OpenGL ES ", 10)) { |
| 368 | verptr = (const char *)dc->gl.gl.version + 9; |
| 369 | } |
| 370 | } |
| 371 | |
| 372 | if (!verptr) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 373 | ALOGE("Error, OpenGL ES Lite not supported"); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 374 | rsdGLShutdown(rsc); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 375 | rsc->setWatchdogGL(NULL, 0, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 376 | return false; |
| 377 | } else { |
| 378 | sscanf(verptr, " %i.%i", &dc->gl.gl.majorVersion, &dc->gl.gl.minorVersion); |
| 379 | } |
| 380 | |
| 381 | glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &dc->gl.gl.maxVertexAttribs); |
| 382 | glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &dc->gl.gl.maxVertexUniformVectors); |
| 383 | glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxVertexTextureUnits); |
| 384 | |
| 385 | glGetIntegerv(GL_MAX_VARYING_VECTORS, &dc->gl.gl.maxVaryingVectors); |
| 386 | glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxTextureImageUnits); |
| 387 | |
| 388 | glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &dc->gl.gl.maxFragmentTextureImageUnits); |
| 389 | glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &dc->gl.gl.maxFragmentUniformVectors); |
| 390 | |
| 391 | dc->gl.gl.OES_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions, |
| 392 | "GL_OES_texture_npot"); |
Mathias Agopian | 9170275 | 2012-01-29 22:20:50 -0800 | [diff] [blame] | 393 | dc->gl.gl.IMG_texture_npot = NULL != strstr((const char *)dc->gl.gl.extensions, |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 394 | "GL_IMG_texture_npot"); |
Mathias Agopian | 9170275 | 2012-01-29 22:20:50 -0800 | [diff] [blame] | 395 | dc->gl.gl.NV_texture_npot_2D_mipmap = NULL != strstr((const char *)dc->gl.gl.extensions, |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 396 | "GL_NV_texture_npot_2D_mipmap"); |
| 397 | dc->gl.gl.EXT_texture_max_aniso = 1.0f; |
| 398 | bool hasAniso = NULL != strstr((const char *)dc->gl.gl.extensions, |
| 399 | "GL_EXT_texture_filter_anisotropic"); |
| 400 | if (hasAniso) { |
| 401 | glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &dc->gl.gl.EXT_texture_max_aniso); |
| 402 | } |
| 403 | |
Stephen Hines | 9db7fe2 | 2011-04-20 17:08:14 -0700 | [diff] [blame] | 404 | if (0) { |
| 405 | DumpDebug(dc); |
| 406 | } |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 407 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 408 | dc->gl.shaderCache = new RsdShaderCache(); |
| 409 | dc->gl.vertexArrayState = new RsdVertexArrayState(); |
| 410 | dc->gl.vertexArrayState->init(dc->gl.gl.maxVertexAttribs); |
Alex Sakhartchouk | a949524 | 2011-06-16 11:05:13 -0700 | [diff] [blame] | 411 | dc->gl.currentFrameBuffer = NULL; |
Jason Sams | 9719bd4 | 2012-01-12 14:22:21 -0800 | [diff] [blame] | 412 | dc->mHasGraphics = true; |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 413 | |
Steve Block | 6598201 | 2011-10-20 11:56:00 +0100 | [diff] [blame] | 414 | ALOGV("%p initGLThread end", rsc); |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 415 | rsc->setWatchdogGL(NULL, 0, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 416 | return true; |
| 417 | } |
| 418 | |
| 419 | |
Jason Sams | b322033 | 2012-04-02 14:41:54 -0700 | [diff] [blame] | 420 | bool rsdGLSetInternalSurface(const Context *rsc, RsNativeWindow sur) { |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 421 | RsdHal *dc = (RsdHal *)rsc->mHal.drv; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 422 | |
| 423 | EGLBoolean ret; |
Jason Sams | b322033 | 2012-04-02 14:41:54 -0700 | [diff] [blame] | 424 | if (dc->gl.egl.surface != NULL) { |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 425 | rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 426 | ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surfaceDefault, |
| 427 | dc->gl.egl.surfaceDefault, dc->gl.egl.context); |
| 428 | checkEglError("eglMakeCurrent", ret); |
| 429 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 430 | rsc->setWatchdogGL("eglDestroySurface", __LINE__, __FILE__); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 431 | ret = eglDestroySurface(dc->gl.egl.display, dc->gl.egl.surface); |
| 432 | checkEglError("eglDestroySurface", ret); |
| 433 | |
| 434 | dc->gl.egl.surface = NULL; |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 435 | } |
| 436 | |
Jason Sams | b322033 | 2012-04-02 14:41:54 -0700 | [diff] [blame] | 437 | if (dc->gl.currentWndSurface != NULL) { |
| 438 | dc->gl.currentWndSurface->decStrong(NULL); |
Jason Sams | c33e690 | 2011-06-20 16:58:04 -0700 | [diff] [blame] | 439 | } |
| 440 | |
Jason Sams | b322033 | 2012-04-02 14:41:54 -0700 | [diff] [blame] | 441 | dc->gl.currentWndSurface = (ANativeWindow *)sur; |
| 442 | if (dc->gl.currentWndSurface != NULL) { |
| 443 | dc->gl.currentWndSurface->incStrong(NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 444 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 445 | rsc->setWatchdogGL("eglCreateWindowSurface", __LINE__, __FILE__); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 446 | dc->gl.egl.surface = eglCreateWindowSurface(dc->gl.egl.display, dc->gl.egl.config, |
Jason Sams | b322033 | 2012-04-02 14:41:54 -0700 | [diff] [blame] | 447 | dc->gl.currentWndSurface, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 448 | checkEglError("eglCreateWindowSurface"); |
| 449 | if (dc->gl.egl.surface == EGL_NO_SURFACE) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 450 | ALOGE("eglCreateWindowSurface returned EGL_NO_SURFACE"); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 451 | } |
| 452 | |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 453 | rsc->setWatchdogGL("eglMakeCurrent", __LINE__, __FILE__); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 454 | ret = eglMakeCurrent(dc->gl.egl.display, dc->gl.egl.surface, |
| 455 | dc->gl.egl.surface, dc->gl.egl.context); |
| 456 | checkEglError("eglMakeCurrent", ret); |
| 457 | } |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 458 | rsc->setWatchdogGL(NULL, 0, NULL); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 459 | return true; |
| 460 | } |
| 461 | |
Jason Sams | b322033 | 2012-04-02 14:41:54 -0700 | [diff] [blame] | 462 | bool rsdGLSetSurface(const Context *rsc, uint32_t w, uint32_t h, RsNativeWindow sur) { |
| 463 | RsdHal *dc = (RsdHal *)rsc->mHal.drv; |
| 464 | |
| 465 | if (dc->gl.wndSurface != NULL) { |
| 466 | dc->gl.wndSurface->decStrong(NULL); |
| 467 | dc->gl.wndSurface = NULL; |
| 468 | } |
| 469 | if(w && h) { |
| 470 | // WAR: Some drivers fail to handle 0 size surfaces correctly. Use the |
| 471 | // pbuffer to avoid this pitfall. |
| 472 | dc->gl.wndSurface = (ANativeWindow *)sur; |
| 473 | if (dc->gl.wndSurface != NULL) { |
| 474 | dc->gl.wndSurface->incStrong(NULL); |
| 475 | } |
| 476 | } |
| 477 | |
| 478 | return rsdGLSetInternalSurface(rsc, sur); |
| 479 | } |
| 480 | |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 481 | void rsdGLSwap(const android::renderscript::Context *rsc) { |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 482 | RsdHal *dc = (RsdHal *)rsc->mHal.drv; |
Jason Sams | 2382aba | 2011-09-13 15:41:01 -0700 | [diff] [blame] | 483 | RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface); |
Jason Sams | 4b3de47 | 2011-04-06 17:52:23 -0700 | [diff] [blame] | 484 | } |
| 485 | |
Jason Sams | 9719bd4 | 2012-01-12 14:22:21 -0800 | [diff] [blame] | 486 | void rsdGLSetPriority(const Context *rsc, int32_t priority) { |
| 487 | if (priority > 0) { |
| 488 | // Mark context as low priority. |
| 489 | ALOGV("low pri"); |
| 490 | } else { |
| 491 | ALOGV("normal pri"); |
| 492 | } |
| 493 | } |
| 494 | |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 495 | void rsdGLCheckError(const android::renderscript::Context *rsc, |
| 496 | const char *msg, bool isFatal) { |
| 497 | GLenum err = glGetError(); |
| 498 | if (err != GL_NO_ERROR) { |
| 499 | char buf[1024]; |
| 500 | snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg); |
| 501 | |
| 502 | if (isFatal) { |
| 503 | rsc->setError(RS_ERROR_FATAL_DRIVER, buf); |
| 504 | } else { |
| 505 | switch (err) { |
| 506 | case GL_OUT_OF_MEMORY: |
| 507 | rsc->setError(RS_ERROR_OUT_OF_MEMORY, buf); |
| 508 | break; |
| 509 | default: |
| 510 | rsc->setError(RS_ERROR_DRIVER, buf); |
| 511 | break; |
| 512 | } |
| 513 | } |
| 514 | |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 515 | ALOGE("%p, %s", rsc, buf); |
Alex Sakhartchouk | c19ff01 | 2011-05-06 14:59:45 -0700 | [diff] [blame] | 516 | } |
| 517 | |
| 518 | } |
Alex Sakhartchouk | 653b53e | 2012-02-24 14:22:34 -0800 | [diff] [blame] | 519 | |
| 520 | void rsdGLClearColor(const android::renderscript::Context *rsc, |
| 521 | float r, float g, float b, float a) { |
| 522 | RSD_CALL_GL(glClearColor, r, g, b, a); |
| 523 | RSD_CALL_GL(glClear, GL_COLOR_BUFFER_BIT); |
| 524 | } |
| 525 | |
| 526 | void rsdGLClearDepth(const android::renderscript::Context *rsc, float v) { |
| 527 | RSD_CALL_GL(glClearDepthf, v); |
| 528 | RSD_CALL_GL(glClear, GL_DEPTH_BUFFER_BIT); |
| 529 | } |
| 530 | |
| 531 | void rsdGLFinish(const android::renderscript::Context *rsc) { |
| 532 | RSD_CALL_GL(glFinish); |
| 533 | } |
| 534 | |
| 535 | void rsdGLDrawQuadTexCoords(const android::renderscript::Context *rsc, |
| 536 | float x1, float y1, float z1, float u1, float v1, |
| 537 | float x2, float y2, float z2, float u2, float v2, |
| 538 | float x3, float y3, float z3, float u3, float v3, |
| 539 | float x4, float y4, float z4, float u4, float v4) { |
| 540 | |
| 541 | float vtx[] = {x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4}; |
| 542 | const float tex[] = {u1,v1, u2,v2, u3,v3, u4,v4}; |
| 543 | |
| 544 | RsdVertexArray::Attrib attribs[2]; |
Tim Murray | e195a3f | 2014-03-13 15:04:58 -0700 | [diff] [blame^] | 545 | |
| 546 | attribs[0].set(GL_FLOAT, 3, 12, false, (size_t)vtx, "ATTRIB_position"); |
| 547 | attribs[1].set(GL_FLOAT, 2, 8, false, (size_t)tex, "ATTRIB_texture0"); |
Alex Sakhartchouk | 653b53e | 2012-02-24 14:22:34 -0800 | [diff] [blame] | 548 | |
| 549 | RsdVertexArray va(attribs, 2); |
| 550 | va.setup(rsc); |
| 551 | |
| 552 | RSD_CALL_GL(glDrawArrays, GL_TRIANGLE_FAN, 0, 4); |
| 553 | } |