opengl/libs/EGL/trace.cpp

   1 /*
   2  ** Copyright 2010, 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 #if EGL_TRACE
  18
  19 #include <stdarg.h>
  20 #include <stdlib.h>
  21
  22 #include <EGL/egl.h>
  23 #include <EGL/eglext.h>
  24
  25 #include <cutils/log.h>
  26
  27 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
  28 #include <utils/Trace.h>
  29
  30 #include <utils/CallStack.h>
  31
  32 #include "egl_tls.h"
  33 #include "hooks.h"
  34
  35 // ----------------------------------------------------------------------------
  36 namespace android {
  37 // ----------------------------------------------------------------------------
  38
  39 struct GLenumString {
  40     // The GL_TIMEOUT_IGNORED "enum" doesn't fit in a GLenum, so use GLuint64
  41     GLuint64 e;
  42     const char* s;
  43 };
  44
  45 #undef GL_ENUM
  46 #define GL_ENUM(VAL,NAME) {VAL, #NAME},
  47
  48 static GLenumString g_enumnames[] = {
  49 #include "enums.in"
  50 };
  51 #undef GL_ENUM
  52
  53 static int compareGLEnum(const void* a, const void* b) {
  54     return ((const GLenumString*) a)->e - ((const GLenumString*) b)->e;
  55 }
  56
  57 static const char* GLEnumToString(GLenum e) {
  58     GLenumString key = {e, ""};
  59     const GLenumString* result = (const GLenumString*) bsearch(
  60         &key, g_enumnames,
  61         sizeof(g_enumnames) / sizeof(g_enumnames[0]),
  62         sizeof(g_enumnames[0]), compareGLEnum);
  63     if (result) {
  64         return result->s;
  65     }
  66     return NULL;
  67 }
  68
  69 static const char* GLbooleanToString(GLboolean arg) {
  70     return arg ? "GL_TRUE" : "GL_FALSE";
  71 }
  72
  73 static GLenumString g_bitfieldNames[] = {
  74     {0x00004000, "GL_COLOR_BUFFER_BIT"},
  75     {0x00000400, "GL_STENCIL_BUFFER_BIT"},
  76     {0x00000100, "GL_DEPTH_BUFFER_BIT"}
  77 };
  78
  79 class StringBuilder {
  80     static const int lineSize = 500;
  81     char line[lineSize];
  82     int line_index;
  83 public:
  84     StringBuilder() {
  85         line_index = 0;
  86         line[0] = '\0';
  87     }
  88     void append(const char* fmt, ...) {
  89         va_list argp;
  90         va_start(argp, fmt);
  91         line_index += vsnprintf(line + line_index, lineSize-line_index, fmt, argp);
  92         va_end(argp);
  93     }
  94     const char* getString() {
  95         line_index = 0;
  96         line[lineSize-1] = '\0';
  97         return line;
  98     }
  99 };
 100
 101
 102 static void TraceGLShaderSource(GLuint shader, GLsizei count,
 103     const GLchar** string, const GLint* length) {
 104     ALOGD("const char* shaderSrc[] = {");
 105     for (GLsizei i = 0; i < count; i++) {
 106         const char* comma = i < count-1 ? "," : "";
 107         const GLchar* s = string[i];
 108         if (length) {
 109             GLint len = length[i];
 110             ALOGD("    \"%*s\"%s", len, s, comma);
 111         } else {
 112             ALOGD("    \"%s\"%s", s, comma);
 113         }
 114     }
 115     ALOGD("};");
 116     if (length) {
 117         ALOGD("const GLint* shaderLength[] = {");
 118         for (GLsizei i = 0; i < count; i++) {
 119             const char* comma = i < count-1 ? "," : "";
 120             GLint len = length[i];
 121             ALOGD("    \"%d\"%s", len, comma);
 122         }
 123         ALOGD("};");
 124         ALOGD("glShaderSource(%u, %u, shaderSrc, shaderLength);",
 125             shader, count);
 126     } else {
 127         ALOGD("glShaderSource(%u, %u, shaderSrc, (const GLint*) 0);",
 128             shader, count);
 129     }
 130 }
 131
 132 static void TraceValue(int elementCount, char type,
 133         GLsizei chunkCount, GLsizei chunkSize, const void* value) {
 134     StringBuilder stringBuilder;
 135     GLsizei count = chunkCount * chunkSize;
 136     bool isFloat = type == 'f';
 137     const char* typeString = isFloat ? "GLfloat" : "GLint";
 138     ALOGD("const %s value[] = {", typeString);
 139     for (GLsizei i = 0; i < count; i++) {
 140         StringBuilder builder;
 141         builder.append("    ");
 142         for (int e = 0; e < elementCount; e++) {
 143             const char* comma = ", ";
 144             if (e == elementCount-1) {
 145                 if (i == count - 1) {
 146                     comma = "";
 147                 } else {
 148                     comma = ",";
 149                 }
 150             }
 151             if (isFloat) {
 152                 builder.append("%g%s", * (GLfloat*) value, comma);
 153                 value = (void*) (((GLfloat*) value) + 1);
 154             } else {
 155                 builder.append("%d%s", * (GLint*) value, comma);
 156                 value = (void*) (((GLint*) value) + 1);
 157             }
 158         }
 159         ALOGD("%s", builder.getString());
 160         if (chunkSize > 1 && i < count-1
 161                 && (i % chunkSize) == (chunkSize-1)) {
 162             ALOGD("%s", ""); // Print a blank line.
 163         }
 164     }
 165     ALOGD("};");
 166 }
 167
 168 static void TraceUniformv(int elementCount, char type,
 169         GLuint location, GLsizei count, const void* value) {
 170     TraceValue(elementCount, type, count, 1, value);
 171     ALOGD("glUniform%d%c(%u, %u, value);", elementCount, type, location, count);
 172 }
 173
 174 static void TraceUniformMatrix(int matrixSideLength,
 175         GLuint location, GLsizei count, GLboolean transpose, const void* value) {
 176     TraceValue(matrixSideLength, 'f', count, matrixSideLength, value);
 177     ALOGD("glUniformMatrix%dfv(%u, %u, %s, value);", matrixSideLength, location, count,
 178             GLbooleanToString(transpose));
 179 }
 180
 181 static void TraceGL(const char* name, int numArgs, ...) {
 182     va_list argp;
 183     va_start(argp, numArgs);
 184     int nameLen = strlen(name);
 185
 186     // glShaderSource
 187     if (nameLen == 14 && strcmp(name, "glShaderSource") == 0) {
 188         va_arg(argp, const char*);
 189         GLuint shader = va_arg(argp, GLuint);
 190         va_arg(argp, const char*);
 191         GLsizei count = va_arg(argp, GLsizei);
 192         va_arg(argp, const char*);
 193         const GLchar** string = (const GLchar**) va_arg(argp, void*);
 194         va_arg(argp, const char*);
 195         const GLint* length = (const GLint*) va_arg(argp, void*);
 196         va_end(argp);
 197         TraceGLShaderSource(shader, count, string, length);
 198         return;
 199     }
 200
 201     // glUniformXXv
 202
 203     if (nameLen == 12 && strncmp(name, "glUniform", 9) == 0 && name[11] == 'v') {
 204         int elementCount = name[9] - '0'; // 1..4
 205         char type = name[10]; // 'f' or 'i'
 206         va_arg(argp, const char*);
 207         GLuint location = va_arg(argp, GLuint);
 208         va_arg(argp, const char*);
 209         GLsizei count = va_arg(argp, GLsizei);
 210         va_arg(argp, const char*);
 211         const void* value = (const void*) va_arg(argp, void*);
 212         va_end(argp);
 213         TraceUniformv(elementCount, type, location, count, value);
 214         return;
 215     }
 216
 217     // glUniformMatrixXfv
 218
 219     if (nameLen == 18 && strncmp(name, "glUniformMatrix", 15) == 0
 220             && name[16] == 'f' && name[17] == 'v') {
 221         int matrixSideLength = name[15] - '0'; // 2..4
 222         va_arg(argp, const char*);
 223         GLuint location = va_arg(argp, GLuint);
 224         va_arg(argp, const char*);
 225         GLsizei count = va_arg(argp, GLsizei);
 226         va_arg(argp, const char*);
 227         GLboolean transpose = (GLboolean) va_arg(argp, int);
 228         va_arg(argp, const char*);
 229         const void* value = (const void*) va_arg(argp, void*);
 230         va_end(argp);
 231         TraceUniformMatrix(matrixSideLength, location, count, transpose, value);
 232         return;
 233     }
 234
 235     StringBuilder builder;
 236     builder.append("%s(", name);
 237     for (int i = 0; i < numArgs; i++) {
 238         if (i > 0) {
 239             builder.append(", ");
 240         }
 241         const char* type = va_arg(argp, const char*);
 242         bool isPtr = type[strlen(type)-1] == '*'
 243             || strcmp(type, "GLeglImageOES") == 0;
 244         if (isPtr) {
 245             const void* arg = va_arg(argp, const void*);
 246             builder.append("(%s) 0x%08x", type, (size_t) arg);
 247         } else if (strcmp(type, "GLbitfield") == 0) {
 248             size_t arg = va_arg(argp, size_t);
 249             bool first = true;
 250             for (size_t i = 0; i < sizeof(g_bitfieldNames) / sizeof(g_bitfieldNames[0]); i++) {
 251                 const GLenumString* b = &g_bitfieldNames[i];
 252                 if (b->e & arg) {
 253                     if (first) {
 254                         first = false;
 255                     } else {
 256                         builder.append(" | ");
 257                     }
 258                     builder.append("%s", b->s);
 259                     arg &= ~b->e;
 260                 }
 261             }
 262             if (first || arg != 0) {
 263                 if (!first) {
 264                     builder.append(" | ");
 265                 }
 266                 builder.append("0x%08x", arg);
 267             }
 268         } else if (strcmp(type, "GLboolean") == 0) {
 269             GLboolean arg = va_arg(argp, int);
 270             builder.append("%s", GLbooleanToString(arg));
 271         } else if (strcmp(type, "GLclampf") == 0) {
 272             double arg = va_arg(argp, double);
 273             builder.append("%g", arg);
 274         } else if (strcmp(type, "GLenum") == 0) {
 275             GLenum arg = va_arg(argp, int);
 276             const char* s = GLEnumToString(arg);
 277             if (s) {
 278                 builder.append("%s", s);
 279             } else {
 280                 builder.append("0x%x", arg);
 281             }
 282         } else if (strcmp(type, "GLfixed") == 0) {
 283             int arg = va_arg(argp, int);
 284             builder.append("0x%08x", arg);
 285         } else if (strcmp(type, "GLfloat") == 0) {
 286             double arg = va_arg(argp, double);
 287             builder.append("%g", arg);
 288         } else if (strcmp(type, "GLint") == 0) {
 289             int arg = va_arg(argp, int);
 290             const char* s = NULL;
 291             if (strcmp(name, "glTexParameteri") == 0) {
 292                 s = GLEnumToString(arg);
 293             }
 294             if (s) {
 295                 builder.append("%s", s);
 296             } else {
 297                 builder.append("%d", arg);
 298             }
 299         } else if (strcmp(type, "GLintptr") == 0) {
 300             int arg = va_arg(argp, unsigned int);
 301             builder.append("%u", arg);
 302         } else if (strcmp(type, "GLsizei") == 0) {
 303             int arg = va_arg(argp, size_t);
 304             builder.append("%u", arg);
 305         } else if (strcmp(type, "GLsizeiptr") == 0) {
 306             int arg = va_arg(argp, size_t);
 307             builder.append("%u", arg);
 308         } else if (strcmp(type, "GLuint") == 0) {
 309             int arg = va_arg(argp, unsigned int);
 310             builder.append("%u", arg);
 311         } else {
 312             builder.append("/* ??? %s */", type);
 313             break;
 314         }
 315     }
 316     builder.append(");");
 317     ALOGD("%s", builder.getString());
 318     va_end(argp);
 319 }
 320
 321 ///////////////////////////////////////////////////////////////////////////
 322 // Log trace
 323 ///////////////////////////////////////////////////////////////////////////
 324
 325 #undef TRACE_GL_VOID
 326 #undef TRACE_GL
 327
 328 #define TRACE_GL_VOID(_api, _args, _argList, ...)                         \
 329 static void Tracing_ ## _api _args {                                      \
 330     TraceGL(#_api, __VA_ARGS__);                                          \
 331     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 332     _c->_api _argList;                                                    \
 333 }
 334
 335 #define TRACE_GL(_type, _api, _args, _argList, ...)                       \
 336 static _type Tracing_ ## _api _args {                                     \
 337     TraceGL(#_api, __VA_ARGS__);                                        \
 338     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 339     return _c->_api _argList;                                             \
 340 }
 341
 342 extern "C" {
 343 #include "../trace.in"
 344 }
 345
 346 #undef TRACE_GL_VOID
 347 #undef TRACE_GL
 348
 349 #define GL_ENTRY(_r, _api, ...) Tracing_ ## _api,
 350 EGLAPI gl_hooks_t gHooksTrace = {
 351     {
 352         #include "entries.in"
 353     },
 354     {
 355         {0}
 356     }
 357 };
 358 #undef GL_ENTRY
 359
 360 #undef TRACE_GL_VOID
 361 #undef TRACE_GL
 362
 363 // define the ES 1.0 Debug_gl* functions as Tracing_gl functions
 364 #define TRACE_GL_VOID(_api, _args, _argList, ...)                         \
 365 static void Debug_ ## _api _args {                                      \
 366     TraceGL(#_api, __VA_ARGS__);                                          \
 367     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 368     _c->_api _argList;                                                    \
 369 }
 370
 371 #define TRACE_GL(_type, _api, _args, _argList, ...)                       \
 372 static _type Debug_ ## _api _args {                                     \
 373     TraceGL(#_api, __VA_ARGS__);                                        \
 374     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 375     return _c->_api _argList;                                             \
 376 }
 377
 378 extern "C" {
 379 #include "../debug.in"
 380 }
 381
 382 ///////////////////////////////////////////////////////////////////////////
 383 // Systrace
 384 ///////////////////////////////////////////////////////////////////////////
 385
 386 #undef TRACE_GL_VOID
 387 #undef TRACE_GL
 388
 389 #define TRACE_GL_VOID(_api, _args, _argList, ...)                         \
 390 static void Systrace_ ## _api _args {                                     \
 391     ATRACE_NAME(#_api);                                                   \
 392     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 393     _c->_api _argList;                                                    \
 394 }
 395
 396 #define TRACE_GL(_type, _api, _args, _argList, ...)                       \
 397 static _type Systrace_ ## _api _args {                                    \
 398     ATRACE_NAME(#_api);                                                   \
 399     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 400     return _c->_api _argList;                                             \
 401 }
 402
 403 extern "C" {
 404 #include "../trace.in"
 405 }
 406
 407 #undef TRACE_GL_VOID
 408 #undef TRACE_GL
 409
 410 #define GL_ENTRY(_r, _api, ...) Systrace_ ## _api,
 411 EGLAPI gl_hooks_t gHooksSystrace = {
 412     {
 413         #include "entries.in"
 414     },
 415     {
 416         {0}
 417     }
 418 };
 419 #undef GL_ENTRY
 420
 421 ///////////////////////////////////////////////////////////////////////////
 422 //
 423 ///////////////////////////////////////////////////////////////////////////
 424
 425 #undef TRACE_GL_VOID
 426 #undef TRACE_GL
 427
 428 #define CHECK_ERROR(_c, _api)                                             \
 429     GLenum status = GL_NO_ERROR;                                          \
 430     bool error = false;                                                   \
 431     while ((status = _c->glGetError()) != GL_NO_ERROR) {                  \
 432         ALOGD("[" #_api "] 0x%x", status);                                \
 433         error = true;                                                     \
 434     }                                                                     \
 435     if (error) {                                                          \
 436         CallStack s;                                                      \
 437         s.update();                                                       \
 438         s.log("glGetError:" #_api);                                       \
 439     }                                                                     \
 440
 441 #define TRACE_GL_VOID(_api, _args, _argList, ...)                         \
 442 static void ErrorTrace_ ## _api _args {                                   \
 443     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 444     _c->_api _argList;                                                    \
 445     CHECK_ERROR(_c, _api);                                                \
 446 }
 447
 448 #define TRACE_GL(_type, _api, _args, _argList, ...)                       \
 449 static _type ErrorTrace_ ## _api _args {                                  \
 450     gl_hooks_t::gl_t const * const _c = &getGLTraceThreadSpecific()->gl;  \
 451     _type _r = _c->_api _argList;                                         \
 452     CHECK_ERROR(_c, _api);                                                \
 453     return _r;                                                            \
 454 }
 455
 456 extern "C" {
 457 #include "../trace.in"
 458 }
 459
 460 #undef TRACE_GL_VOID
 461 #undef TRACE_GL
 462
 463 #define GL_ENTRY(_r, _api, ...) ErrorTrace_ ## _api,
 464 EGLAPI gl_hooks_t gHooksErrorTrace = {
 465     {
 466         #include "entries.in"
 467     },
 468     {
 469         {0}
 470     }
 471 };
 472 #undef GL_ENTRY
 473 #undef CHECK_ERROR
 474
 475 #undef TRACE_GL_VOID
 476 #undef TRACE_GL
 477
 478 // ----------------------------------------------------------------------------
 479 }; // namespace android
 480 // ----------------------------------------------------------------------------
 481
 482 #endif // EGL_TRACE