1 /*
2 ** Copyright 2007, 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 <ctype.h>
18 #include <stdlib.h>
19 #include <string.h>
20
21 #include <hardware/gralloc.h>
22 #include <system/window.h>
23
24 #include <EGL/egl.h>
25 #include <EGL/eglext.h>
26 #include <GLES/gl.h>
27 #include <GLES/glext.h>
28
29 #include <cutils/log.h>
30 #include <cutils/atomic.h>
31 #include <cutils/properties.h>
32 #include <cutils/memory.h>
33
34 #include <utils/CallStack.h>
35 #include <utils/String8.h>
36
37 #include "egldefs.h"
38 #include "egl_impl.h"
39 #include "egl_tls.h"
40 #include "glestrace.h"
41 #include "hooks.h"
42 #include "Loader.h"
43
44 #include "egl_display.h"
45 #include "egl_object.h"
46
47 // ----------------------------------------------------------------------------
48 namespace android {
49 // ----------------------------------------------------------------------------
50
51 egl_connection_t gEGLImpl;
52 gl_hooks_t gHooks[2];
53 gl_hooks_t gHooksNoContext;
54 pthread_key_t gGLWrapperKey = -1;
55
56 // ----------------------------------------------------------------------------
57
58 #if EGL_TRACE
59
60 EGLAPI pthread_key_t gGLTraceKey = -1;
61
62 // ----------------------------------------------------------------------------
63
64 /**
65 * There are two different tracing methods:
66 * 1. libs/EGL/trace.cpp: Traces all functions to logcat.
67 * To enable:
68 * - set system property "debug.egl.trace" to 1 to trace all apps.
69 * - or call setGLTraceLevel(1) from an app to enable tracing for that app.
70 * 2. libs/GLES_trace: Traces all functions via protobuf to host.
71 * To enable:
72 * - set system property "debug.egl.debug_proc" to the application name.
73 * - or call setGLDebugLevel(1) from the app.
74 */
75 static int sEGLTraceLevel;
76 static int sEGLApplicationTraceLevel;
77
78 int gEGLDebugLevel;
79 static int sEGLApplicationDebugLevel;
80
81 extern gl_hooks_t gHooksTrace;
82
setGlTraceThreadSpecific(gl_hooks_t const * value)83 static inline void setGlTraceThreadSpecific(gl_hooks_t const *value) {
84 pthread_setspecific(gGLTraceKey, value);
85 }
86
getGLTraceThreadSpecific()87 gl_hooks_t const* getGLTraceThreadSpecific() {
88 return static_cast<gl_hooks_t*>(pthread_getspecific(gGLTraceKey));
89 }
90
initEglTraceLevel()91 void initEglTraceLevel() {
92 char value[PROPERTY_VALUE_MAX];
93 property_get("debug.egl.trace", value, "0");
94 int propertyLevel = atoi(value);
95 int applicationLevel = sEGLApplicationTraceLevel;
96 sEGLTraceLevel = propertyLevel > applicationLevel ? propertyLevel : applicationLevel;
97 }
98
initEglDebugLevel()99 void initEglDebugLevel() {
100 int propertyLevel = 0;
101 char value[PROPERTY_VALUE_MAX];
102 property_get("debug.egl.debug_proc", value, "");
103 if (strlen(value) > 0) {
104 long pid = getpid();
105 char procPath[128] = {};
106 sprintf(procPath, "/proc/%ld/cmdline", pid);
107 FILE * file = fopen(procPath, "r");
108 if (file) {
109 char cmdline[256] = {};
110 if (fgets(cmdline, sizeof(cmdline) - 1, file)) {
111 if (!strncmp(value, cmdline, strlen(value))) {
112 // set EGL debug if the "debug.egl.debug_proc" property
113 // matches the prefix of this application's command line
114 propertyLevel = 1;
115 }
116 }
117 fclose(file);
118 }
119 }
120
121 gEGLDebugLevel = propertyLevel || sEGLApplicationDebugLevel;
122 if (gEGLDebugLevel > 0) {
123 GLTrace_start();
124 }
125 }
126
setGLHooksThreadSpecific(gl_hooks_t const * value)127 void setGLHooksThreadSpecific(gl_hooks_t const *value) {
128 if (sEGLTraceLevel > 0) {
129 setGlTraceThreadSpecific(value);
130 setGlThreadSpecific(&gHooksTrace);
131 } else if (gEGLDebugLevel > 0 && value != &gHooksNoContext) {
132 setGlTraceThreadSpecific(value);
133 setGlThreadSpecific(GLTrace_getGLHooks());
134 } else {
135 setGlThreadSpecific(value);
136 }
137 }
138
139 /*
140 * Global entry point to allow applications to modify their own trace level.
141 * The effective trace level is the max of this level and the value of debug.egl.trace.
142 */
143 extern "C"
setGLTraceLevel(int level)144 void setGLTraceLevel(int level) {
145 sEGLApplicationTraceLevel = level;
146 }
147
148 /*
149 * Global entry point to allow applications to modify their own debug level.
150 * Debugging is enabled if either the application requested it, or if the system property
151 * matches the application's name.
152 */
setGLDebugLevel(int level)153 void EGLAPI setGLDebugLevel(int level) {
154 sEGLApplicationDebugLevel = level;
155 }
156
157 #else
158
setGLHooksThreadSpecific(gl_hooks_t const * value)159 void setGLHooksThreadSpecific(gl_hooks_t const *value) {
160 setGlThreadSpecific(value);
161 }
162
163 #endif
164
165 /*****************************************************************************/
166
gl_no_context()167 static int gl_no_context() {
168 if (egl_tls_t::logNoContextCall()) {
169 ALOGE("call to OpenGL ES API with no current context "
170 "(logged once per thread)");
171 char value[PROPERTY_VALUE_MAX];
172 property_get("debug.egl.callstack", value, "0");
173 if (atoi(value)) {
174 CallStack stack;
175 stack.update();
176 stack.dump();
177 }
178 }
179 return 0;
180 }
181
early_egl_init(void)182 static void early_egl_init(void)
183 {
184 #if !USE_FAST_TLS_KEY
185 pthread_key_create(&gGLWrapperKey, NULL);
186 #endif
187 #if EGL_TRACE
188 pthread_key_create(&gGLTraceKey, NULL);
189 initEglTraceLevel();
190 initEglDebugLevel();
191 #endif
192 uint32_t addr = (uint32_t)((void*)gl_no_context);
193 android_memset32(
194 (uint32_t*)(void*)&gHooksNoContext,
195 addr,
196 sizeof(gHooksNoContext));
197
198 setGLHooksThreadSpecific(&gHooksNoContext);
199 }
200
201 static pthread_once_t once_control = PTHREAD_ONCE_INIT;
202 static int sEarlyInitState = pthread_once(&once_control, &early_egl_init);
203
204 // ----------------------------------------------------------------------------
205
validate_display(EGLDisplay dpy)206 egl_display_ptr validate_display(EGLDisplay dpy) {
207 egl_display_ptr dp = get_display(dpy);
208 if (!dp)
209 return setError(EGL_BAD_DISPLAY, egl_display_ptr(NULL));
210 if (!dp->isReady())
211 return setError(EGL_NOT_INITIALIZED, egl_display_ptr(NULL));
212
213 return dp;
214 }
215
validate_display_connection(EGLDisplay dpy,egl_connection_t * & cnx)216 egl_display_ptr validate_display_connection(EGLDisplay dpy,
217 egl_connection_t*& cnx) {
218 cnx = NULL;
219 egl_display_ptr dp = validate_display(dpy);
220 if (!dp)
221 return dp;
222 cnx = &gEGLImpl;
223 if (cnx->dso == 0) {
224 return setError(EGL_BAD_CONFIG, egl_display_ptr(NULL));
225 }
226 return dp;
227 }
228
229 // ----------------------------------------------------------------------------
230
egl_get_string_for_current_context(GLenum name)231 const GLubyte * egl_get_string_for_current_context(GLenum name) {
232 // NOTE: returning NULL here will fall-back to the default
233 // implementation.
234
235 EGLContext context = egl_tls_t::getContext();
236 if (context == EGL_NO_CONTEXT)
237 return NULL;
238
239 egl_context_t const * const c = get_context(context);
240 if (c == NULL) // this should never happen, by construction
241 return NULL;
242
243 if (name != GL_EXTENSIONS)
244 return NULL;
245
246 return (const GLubyte *)c->gl_extensions.string();
247 }
248
249 // ----------------------------------------------------------------------------
250
251 // this mutex protects:
252 // d->disp[]
253 // egl_init_drivers_locked()
254 //
egl_init_drivers_locked()255 static EGLBoolean egl_init_drivers_locked() {
256 if (sEarlyInitState) {
257 // initialized by static ctor. should be set here.
258 return EGL_FALSE;
259 }
260
261 // get our driver loader
262 Loader& loader(Loader::getInstance());
263
264 // dynamically load our EGL implementation
265 egl_connection_t* cnx = &gEGLImpl;
266 if (cnx->dso == 0) {
267 cnx->hooks[egl_connection_t::GLESv1_INDEX] =
268 &gHooks[egl_connection_t::GLESv1_INDEX];
269 cnx->hooks[egl_connection_t::GLESv2_INDEX] =
270 &gHooks[egl_connection_t::GLESv2_INDEX];
271 cnx->dso = loader.open(cnx);
272 }
273
274 return cnx->dso ? EGL_TRUE : EGL_FALSE;
275 }
276
277 static pthread_mutex_t sInitDriverMutex = PTHREAD_MUTEX_INITIALIZER;
278
egl_init_drivers()279 EGLBoolean egl_init_drivers() {
280 EGLBoolean res;
281 pthread_mutex_lock(&sInitDriverMutex);
282 res = egl_init_drivers_locked();
283 pthread_mutex_unlock(&sInitDriverMutex);
284 return res;
285 }
286
gl_unimplemented()287 void gl_unimplemented() {
288 ALOGE("called unimplemented OpenGL ES API");
289 }
290
gl_noop()291 void gl_noop() {
292 }
293
294 // ----------------------------------------------------------------------------
295
296 #if USE_FAST_TLS_KEY
297
298 // We have a dedicated TLS slot in bionic
get_tls_hooks()299 static inline gl_hooks_t const * volatile * get_tls_hooks() {
300 volatile void *tls_base = __get_tls();
301 gl_hooks_t const * volatile * tls_hooks =
302 reinterpret_cast<gl_hooks_t const * volatile *>(tls_base);
303 return tls_hooks;
304 }
305
setGlThreadSpecific(gl_hooks_t const * value)306 void setGlThreadSpecific(gl_hooks_t const *value) {
307 gl_hooks_t const * volatile * tls_hooks = get_tls_hooks();
308 tls_hooks[TLS_SLOT_OPENGL_API] = value;
309 }
310
getGlThreadSpecific()311 gl_hooks_t const* getGlThreadSpecific() {
312 gl_hooks_t const * volatile * tls_hooks = get_tls_hooks();
313 gl_hooks_t const* hooks = tls_hooks[TLS_SLOT_OPENGL_API];
314 if (hooks) return hooks;
315 return &gHooksNoContext;
316 }
317
318 #else
319
setGlThreadSpecific(gl_hooks_t const * value)320 void setGlThreadSpecific(gl_hooks_t const *value) {
321 pthread_setspecific(gGLWrapperKey, value);
322 }
323
getGlThreadSpecific()324 gl_hooks_t const* getGlThreadSpecific() {
325 gl_hooks_t const* hooks = static_cast<gl_hooks_t*>(pthread_getspecific(gGLWrapperKey));
326 if (hooks) return hooks;
327 return &gHooksNoContext;
328 }
329
330 #endif
331
332 // ----------------------------------------------------------------------------
333 // GL / EGL hooks
334 // ----------------------------------------------------------------------------
335
336 #undef GL_ENTRY
337 #undef EGL_ENTRY
338 #define GL_ENTRY(_r, _api, ...) #_api,
339 #define EGL_ENTRY(_r, _api, ...) #_api,
340
341 char const * const gl_names[] = {
342 #include "entries.in"
343 NULL
344 };
345
346 char const * const egl_names[] = {
347 #include "egl_entries.in"
348 NULL
349 };
350
351 #undef GL_ENTRY
352 #undef EGL_ENTRY
353
354
355 // ----------------------------------------------------------------------------
356 }; // namespace android
357 // ----------------------------------------------------------------------------
358
359