1/*
2 * Copyright (C) 2008 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
17package android.opengl;
18
19import java.io.IOException;
20import java.io.Writer;
21
22import javax.microedition.khronos.egl.EGL;
23import javax.microedition.khronos.egl.EGL10;
24import javax.microedition.khronos.egl.EGL11;
25import javax.microedition.khronos.egl.EGLConfig;
26import javax.microedition.khronos.egl.EGLContext;
27import javax.microedition.khronos.egl.EGLDisplay;
28import javax.microedition.khronos.egl.EGLSurface;
29
30class EGLLogWrapper implements EGL11 {
31    private EGL10 mEgl10;
32    Writer mLog;
33    boolean mLogArgumentNames;
34    boolean mCheckError;
35    private int mArgCount;
36
37
38    public EGLLogWrapper(EGL egl, int configFlags, Writer log) {
39        mEgl10 = (EGL10) egl;
40        mLog = log;
41        mLogArgumentNames =
42            (GLDebugHelper.CONFIG_LOG_ARGUMENT_NAMES & configFlags) != 0;
43        mCheckError =
44            (GLDebugHelper.CONFIG_CHECK_GL_ERROR & configFlags) != 0;
45    }
46
47    public boolean eglChooseConfig(EGLDisplay display, int[] attrib_list,
48            EGLConfig[] configs, int config_size, int[] num_config) {
49        begin("eglChooseConfig");
50        arg("display", display);
51        arg("attrib_list", attrib_list);
52        arg("config_size", config_size);
53        end();
54
55        boolean result = mEgl10.eglChooseConfig(display, attrib_list, configs,
56                config_size, num_config);
57        arg("configs", configs);
58        arg("num_config", num_config);
59        returns(result);
60        checkError();
61        return result;
62    }
63
64    public boolean eglCopyBuffers(EGLDisplay display, EGLSurface surface,
65            Object native_pixmap) {
66        begin("eglCopyBuffers");
67        arg("display", display);
68        arg("surface", surface);
69        arg("native_pixmap", native_pixmap);
70        end();
71
72        boolean result = mEgl10.eglCopyBuffers(display, surface, native_pixmap);
73        returns(result);
74        checkError();
75        return result;
76    }
77
78    public EGLContext eglCreateContext(EGLDisplay display, EGLConfig config,
79            EGLContext share_context, int[] attrib_list) {
80        begin("eglCreateContext");
81        arg("display", display);
82        arg("config", config);
83        arg("share_context", share_context);
84        arg("attrib_list", attrib_list);
85        end();
86
87        EGLContext result = mEgl10.eglCreateContext(display, config,
88                share_context, attrib_list);
89        returns(result);
90        checkError();
91        return result;
92    }
93
94    public EGLSurface eglCreatePbufferSurface(EGLDisplay display,
95            EGLConfig config, int[] attrib_list) {
96        begin("eglCreatePbufferSurface");
97        arg("display", display);
98        arg("config", config);
99        arg("attrib_list", attrib_list);
100        end();
101
102        EGLSurface result = mEgl10.eglCreatePbufferSurface(display, config,
103                attrib_list);
104        returns(result);
105        checkError();
106        return result;
107    }
108
109    public EGLSurface eglCreatePixmapSurface(EGLDisplay display,
110            EGLConfig config, Object native_pixmap, int[] attrib_list) {
111        begin("eglCreatePixmapSurface");
112        arg("display", display);
113        arg("config", config);
114        arg("native_pixmap", native_pixmap);
115        arg("attrib_list", attrib_list);
116        end();
117
118        EGLSurface result = mEgl10.eglCreatePixmapSurface(display, config,
119                native_pixmap, attrib_list);
120        returns(result);
121        checkError();
122        return result;
123        }
124
125    public EGLSurface eglCreateWindowSurface(EGLDisplay display,
126            EGLConfig config, Object native_window, int[] attrib_list) {
127        begin("eglCreateWindowSurface");
128        arg("display", display);
129        arg("config", config);
130        arg("native_window", native_window);
131        arg("attrib_list", attrib_list);
132        end();
133
134        EGLSurface result = mEgl10.eglCreateWindowSurface(display, config,
135                native_window, attrib_list);
136        returns(result);
137        checkError();
138        return result;
139    }
140
141    public boolean eglDestroyContext(EGLDisplay display, EGLContext context) {
142        begin("eglDestroyContext");
143        arg("display", display);
144        arg("context", context);
145        end();
146
147        boolean result = mEgl10.eglDestroyContext(display, context);
148        returns(result);
149        checkError();
150        return result;
151    }
152
153    public boolean eglDestroySurface(EGLDisplay display, EGLSurface surface) {
154        begin("eglDestroySurface");
155        arg("display", display);
156        arg("surface", surface);
157        end();
158
159        boolean result = mEgl10.eglDestroySurface(display, surface);
160        returns(result);
161        checkError();
162        return result;
163    }
164
165    public boolean eglGetConfigAttrib(EGLDisplay display, EGLConfig config,
166            int attribute, int[] value) {
167        begin("eglGetConfigAttrib");
168        arg("display", display);
169        arg("config", config);
170        arg("attribute", attribute);
171        end();
172        boolean result = mEgl10.eglGetConfigAttrib(display, config, attribute,
173                value);
174        arg("value", value);
175        returns(result);
176        checkError();
177        return false;
178    }
179
180    public boolean eglGetConfigs(EGLDisplay display, EGLConfig[] configs,
181            int config_size, int[] num_config) {
182        begin("eglGetConfigs");
183        arg("display", display);
184        arg("config_size", config_size);
185        end();
186
187        boolean result = mEgl10.eglGetConfigs(display, configs, config_size,
188                num_config);
189        arg("configs", configs);
190        arg("num_config", num_config);
191        returns(result);
192        checkError();
193        return result;
194    }
195
196    public EGLContext eglGetCurrentContext() {
197        begin("eglGetCurrentContext");
198        end();
199
200        EGLContext result = mEgl10.eglGetCurrentContext();
201        returns(result);
202
203        checkError();
204        return result;
205    }
206
207    public EGLDisplay eglGetCurrentDisplay() {
208        begin("eglGetCurrentDisplay");
209        end();
210
211        EGLDisplay result = mEgl10.eglGetCurrentDisplay();
212        returns(result);
213
214        checkError();
215        return result;
216    }
217
218    public EGLSurface eglGetCurrentSurface(int readdraw) {
219        begin("eglGetCurrentSurface");
220        arg("readdraw", readdraw);
221        end();
222
223        EGLSurface result = mEgl10.eglGetCurrentSurface(readdraw);
224        returns(result);
225
226        checkError();
227        return result;
228    }
229
230    public EGLDisplay eglGetDisplay(Object native_display) {
231        begin("eglGetDisplay");
232        arg("native_display", native_display);
233        end();
234
235        EGLDisplay result = mEgl10.eglGetDisplay(native_display);
236        returns(result);
237
238        checkError();
239        return result;
240    }
241
242    public int eglGetError() {
243        begin("eglGetError");
244        end();
245
246        int result = mEgl10.eglGetError();
247        returns(getErrorString(result));
248
249        return result;
250    }
251
252    public boolean eglInitialize(EGLDisplay display, int[] major_minor) {
253        begin("eglInitialize");
254        arg("display", display);
255        end();
256        boolean result = mEgl10.eglInitialize(display, major_minor);
257        returns(result);
258        arg("major_minor", major_minor);
259        checkError();
260        return result;
261    }
262
263    public boolean eglMakeCurrent(EGLDisplay display, EGLSurface draw,
264            EGLSurface read, EGLContext context) {
265        begin("eglMakeCurrent");
266        arg("display", display);
267        arg("draw", draw);
268        arg("read", read);
269        arg("context", context);
270        end();
271        boolean result = mEgl10.eglMakeCurrent(display, draw, read, context);
272        returns(result);
273        checkError();
274        return result;
275    }
276
277    public boolean eglQueryContext(EGLDisplay display, EGLContext context,
278            int attribute, int[] value) {
279        begin("eglQueryContext");
280        arg("display", display);
281        arg("context", context);
282        arg("attribute", attribute);
283        end();
284        boolean result = mEgl10.eglQueryContext(display, context, attribute,
285                value);
286        returns(value[0]);
287        returns(result);
288        checkError();
289        return result;
290    }
291
292    public String eglQueryString(EGLDisplay display, int name) {
293        begin("eglQueryString");
294        arg("display", display);
295        arg("name", name);
296        end();
297        String result = mEgl10.eglQueryString(display, name);
298        returns(result);
299        checkError();
300        return result;
301    }
302
303    public boolean eglQuerySurface(EGLDisplay display, EGLSurface surface,
304            int attribute, int[] value) {
305        begin("eglQuerySurface");
306        arg("display", display);
307        arg("surface", surface);
308        arg("attribute", attribute);
309        end();
310        boolean result = mEgl10.eglQuerySurface(display, surface, attribute,
311                value);
312        returns(value[0]);
313        returns(result);
314        checkError();
315        return result;
316    }
317
318    /** @hide **/
319    public boolean eglReleaseThread() {
320        begin("eglReleaseThread");
321        end();
322        boolean result = mEgl10.eglReleaseThread();
323        returns(result);
324        checkError();
325        return result;
326    }
327
328    public boolean eglSwapBuffers(EGLDisplay display, EGLSurface surface) {
329        begin("eglSwapBuffers");
330        arg("display", display);
331        arg("surface", surface);
332        end();
333        boolean result = mEgl10.eglSwapBuffers(display, surface);
334        returns(result);
335        checkError();
336        return result;
337    }
338
339    public boolean eglTerminate(EGLDisplay display) {
340        begin("eglTerminate");
341        arg("display", display);
342        end();
343        boolean result = mEgl10.eglTerminate(display);
344        returns(result);
345        checkError();
346        return result;
347    }
348
349    public boolean eglWaitGL() {
350        begin("eglWaitGL");
351        end();
352        boolean result = mEgl10.eglWaitGL();
353        returns(result);
354        checkError();
355        return result;
356    }
357
358    public boolean eglWaitNative(int engine, Object bindTarget) {
359        begin("eglWaitNative");
360        arg("engine", engine);
361        arg("bindTarget", bindTarget);
362        end();
363        boolean result = mEgl10.eglWaitNative(engine, bindTarget);
364        returns(result);
365        checkError();
366        return result;
367    }
368
369    private void checkError() {
370        int eglError;
371        if ((eglError = mEgl10.eglGetError()) != EGL_SUCCESS) {
372            String errorMessage = "eglError: " + getErrorString(eglError);
373            logLine(errorMessage);
374            if (mCheckError) {
375                throw new GLException(eglError, errorMessage);
376            }
377        }
378    }
379
380    private void logLine(String message) {
381        log(message + '\n');
382    }
383
384    private void log(String message) {
385        try {
386            mLog.write(message);
387        } catch (IOException e) {
388            // Ignore exception, keep on trying
389        }
390    }
391
392    private void begin(String name) {
393        log(name + '(');
394        mArgCount = 0;
395    }
396
397    private void arg(String name, String value) {
398        if (mArgCount++ > 0) {
399            log(", ");
400        }
401        if (mLogArgumentNames) {
402            log(name + "=");
403        }
404        log(value);
405    }
406
407    private void end() {
408        log(");\n");
409        flush();
410    }
411
412    private void flush() {
413        try {
414            mLog.flush();
415        } catch (IOException e) {
416            mLog = null;
417        }
418    }
419
420    private void arg(String name, int value) {
421        arg(name, Integer.toString(value));
422    }
423
424    private void arg(String name, Object object) {
425        arg(name, toString(object));
426    }
427
428    private void arg(String name, EGLDisplay object) {
429        if (object == EGL10.EGL_DEFAULT_DISPLAY) {
430            arg(name, "EGL10.EGL_DEFAULT_DISPLAY");
431        } else if (object == EGL_NO_DISPLAY) {
432            arg(name, "EGL10.EGL_NO_DISPLAY");
433        } else {
434            arg(name, toString(object));
435        }
436    }
437
438    private void arg(String name, EGLContext object) {
439        if (object == EGL10.EGL_NO_CONTEXT) {
440            arg(name, "EGL10.EGL_NO_CONTEXT");
441        } else {
442            arg(name, toString(object));
443        }
444    }
445
446    private void arg(String name, EGLSurface object) {
447        if (object == EGL10.EGL_NO_SURFACE) {
448            arg(name, "EGL10.EGL_NO_SURFACE");
449        } else {
450            arg(name, toString(object));
451        }
452    }
453
454    private void returns(String result) {
455        log(" returns " + result + ";\n");
456        flush();
457    }
458
459    private void returns(int result) {
460        returns(Integer.toString(result));
461    }
462
463    private void returns(boolean result) {
464        returns(Boolean.toString(result));
465    }
466
467    private void returns(Object result) {
468        returns(toString(result));
469    }
470
471    private String toString(Object obj) {
472        if (obj == null) {
473            return "null";
474        } else {
475            return obj.toString();
476        }
477    }
478
479    private void arg(String name, int[] arr) {
480        if (arr == null) {
481            arg(name, "null");
482        } else {
483            arg(name, toString(arr.length, arr, 0));
484        }
485    }
486
487    private void arg(String name, Object[] arr) {
488        if (arr == null) {
489            arg(name, "null");
490        } else {
491            arg(name, toString(arr.length, arr, 0));
492        }
493    }
494
495    private String toString(int n, int[] arr, int offset) {
496        StringBuilder buf = new StringBuilder();
497        buf.append("{\n");
498        int arrLen = arr.length;
499        for (int i = 0; i < n; i++) {
500            int index = offset + i;
501            buf.append(" [" + index + "] = ");
502            if (index < 0 || index >= arrLen) {
503                buf.append("out of bounds");
504            } else {
505                buf.append(arr[index]);
506            }
507            buf.append('\n');
508        }
509        buf.append("}");
510        return buf.toString();
511    }
512
513    private String toString(int n, Object[] arr, int offset) {
514        StringBuilder buf = new StringBuilder();
515        buf.append("{\n");
516        int arrLen = arr.length;
517        for (int i = 0; i < n; i++) {
518            int index = offset + i;
519            buf.append(" [" + index + "] = ");
520            if (index < 0 || index >= arrLen) {
521                buf.append("out of bounds");
522            } else {
523                buf.append(arr[index]);
524            }
525            buf.append('\n');
526        }
527        buf.append("}");
528        return buf.toString();
529    }
530
531    private static String getHex(int value) {
532        return "0x" + Integer.toHexString(value);
533    }
534
535    public static String getErrorString(int error) {
536        switch (error) {
537        case EGL_SUCCESS:
538            return "EGL_SUCCESS";
539        case EGL_NOT_INITIALIZED:
540            return "EGL_NOT_INITIALIZED";
541        case EGL_BAD_ACCESS:
542            return "EGL_BAD_ACCESS";
543        case EGL_BAD_ALLOC:
544            return "EGL_BAD_ALLOC";
545        case EGL_BAD_ATTRIBUTE:
546            return "EGL_BAD_ATTRIBUTE";
547        case EGL_BAD_CONFIG:
548            return "EGL_BAD_CONFIG";
549        case EGL_BAD_CONTEXT:
550            return "EGL_BAD_CONTEXT";
551        case EGL_BAD_CURRENT_SURFACE:
552            return "EGL_BAD_CURRENT_SURFACE";
553        case EGL_BAD_DISPLAY:
554            return "EGL_BAD_DISPLAY";
555        case EGL_BAD_MATCH:
556            return "EGL_BAD_MATCH";
557        case EGL_BAD_NATIVE_PIXMAP:
558            return "EGL_BAD_NATIVE_PIXMAP";
559        case EGL_BAD_NATIVE_WINDOW:
560            return "EGL_BAD_NATIVE_WINDOW";
561        case EGL_BAD_PARAMETER:
562            return "EGL_BAD_PARAMETER";
563        case EGL_BAD_SURFACE:
564            return "EGL_BAD_SURFACE";
565        case EGL11.EGL_CONTEXT_LOST:
566            return "EGL_CONTEXT_LOST";
567        default:
568            return getHex(error);
569        }
570    }
571}
572