git.cworth.org Git - apitrace/blob - glretrace.py

   1 ##########################################################################
   2 #
   3 # Copyright 2010 VMware, Inc.
   4 # All Rights Reserved.
   5 #
   6 # Permission is hereby granted, free of charge, to any person obtaining a copy
   7 # of this software and associated documentation files (the "Software"), to deal
   8 # in the Software without restriction, including without limitation the rights
   9 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 # copies of the Software, and to permit persons to whom the Software is
  11 # furnished to do so, subject to the following conditions:
  12 #
  13 # The above copyright notice and this permission notice shall be included in
  14 # all copies or substantial portions of the Software.
  15 #
  16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22 # THE SOFTWARE.
  23 #
  24 ##########################################################################/
  25
  26
  27 """GL retracer generator."""
  28
  29
  30 import stdapi
  31 import glapi
  32 from retrace import Retracer
  33
  34
  35 class GlRetracer(Retracer):
  36
  37     def retrace_function(self, function):
  38         Retracer.retrace_function(self, function)
  39
  40     array_pointer_function_names = set((
  41         "glVertexPointer",
  42         "glNormalPointer",
  43         "glColorPointer",
  44         "glIndexPointer",
  45         "glTexCoordPointer",
  46         "glEdgeFlagPointer",
  47         "glFogCoordPointer",
  48         "glSecondaryColorPointer",
  49
  50         "glInterleavedArrays",
  51
  52         #"glVertexPointerEXT",
  53         #"glNormalPointerEXT",
  54         #"glColorPointerEXT",
  55         #"glIndexPointerEXT",
  56         #"glTexCoordPointerEXT",
  57         #"glEdgeFlagPointerEXT",
  58         #"glFogCoordPointerEXT",
  59         #"glSecondaryColorPointerEXT",
  60
  61         #"glVertexAttribPointer",
  62         #"glVertexAttribPointerARB",
  63         #"glVertexAttribPointerNV",
  64         #"glVertexAttribLPointer",
  65
  66         #"glMatrixIndexPointerARB",
  67     ))
  68
  69     draw_array_function_names = set([
  70         "glDrawArrays",
  71         "glDrawArraysEXT",
  72         "glDrawArraysIndirect",
  73         "glDrawArraysInstanced",
  74         "glDrawArraysInstancedARB",
  75         "glDrawArraysInstancedEXT",
  76         "glDrawMeshArraysSUN",
  77         "glMultiDrawArrays",
  78         "glMultiDrawArraysEXT",
  79         "glMultiModeDrawArraysIBM",
  80     ])
  81
  82     draw_elements_function_names = set([
  83         "glDrawElements",
  84         "glDrawElementsBaseVertex",
  85         "glDrawElementsIndirect",
  86         "glDrawElementsInstanced",
  87         "glDrawElementsInstancedARB",
  88         "glDrawElementsInstancedBaseVertex",
  89         "glDrawElementsInstancedEXT",
  90         "glDrawRangeElements",
  91         "glDrawRangeElementsBaseVertex",
  92         "glDrawRangeElementsEXT",
  93         #"glMultiDrawElements",
  94         #"glMultiDrawElementsBaseVertex",
  95         #"glMultiDrawElementsEXT",
  96         #"glMultiModeDrawElementsIBM",
  97     ])
  98
  99     def retrace_function_body(self, function):
 100         is_array_pointer = function.name in self.array_pointer_function_names
 101         is_draw_array = function.name in self.draw_array_function_names
 102         is_draw_elements = function.name in self.draw_elements_function_names
 103
 104         if is_array_pointer or is_draw_array or is_draw_elements:
 105             print '    if (Trace::Parser::version < 1) {'
 106
 107             if is_array_pointer or is_draw_array:
 108                 print '        GLint __array_buffer = 0;'
 109                 print '        glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 110                 print '        if (!__array_buffer) {'
 111                 self.fail_function(function)
 112                 print '        }'
 113
 114             if is_draw_elements:
 115                 print '        GLint __element_array_buffer = 0;'
 116                 print '        glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
 117                 print '        if (!__element_array_buffer) {'
 118                 self.fail_function(function)
 119                 print '        }'
 120
 121             print '    }'
 122
 123         Retracer.retrace_function_body(self, function)
 124
 125     def call_function(self, function):
 126         if function.name == "glViewport":
 127             print '    if (x + width > __window_width) {'
 128             print '        __window_width = x + width;'
 129             print '        __reshape_window = true;'
 130             print '    }'
 131             print '    if (y + height > __window_height) {'
 132             print '        __window_height = y + height;'
 133             print '        __reshape_window = true;'
 134             print '    }'
 135
 136         if function.name == "glEnd":
 137             print '    insideGlBeginEnd = false;'
 138
 139         Retracer.call_function(self, function)
 140
 141         if function.name == "glBegin":
 142             print '    insideGlBeginEnd = true;'
 143         else:
 144             # glGetError is not allowed inside glBegin/glEnd
 145             print '    checkGlError();'
 146
 147     pointer_function_names = set([
 148         "glColorPointer",
 149         #"glColorPointerEXT",
 150         "glEdgeFlagPointer",
 151         #"glEdgeFlagPointerEXT",
 152         "glFogCoordPointer",
 153         #"glFogCoordPointerEXT",
 154         "glIndexPointer",
 155         #"glIndexPointerEXT",
 156         #"glMatrixIndexPointerARB",
 157         "glNormalPointer",
 158         #"glNormalPointerEXT",
 159         "glSecondaryColorPointer",
 160         #"glSecondaryColorPointerEXT",
 161         "glTexCoordPointer",
 162         #"glTexCoordPointerEXT",
 163         #"glVertexAttribLPointer",
 164         #"glVertexAttribPointer",
 165         #"glVertexAttribPointerARB",
 166         #"glVertexAttribPointerNV",
 167         "glVertexPointer",
 168         #"glVertexPointerEXT",
 169     ])
 170
 171     def extract_arg(self, function, arg, arg_type, lvalue, rvalue):
 172         if function.name in self.pointer_function_names and arg.name == 'pointer':
 173             print '    %s = %s.blob();' % (lvalue, rvalue)
 174             return
 175
 176         if function.name in self.draw_elements_function_names and arg.name == 'indices':
 177             print '    %s = %s.blob();' % (lvalue, rvalue)
 178             return
 179
 180         if function.name.startswith('glUniform') and function.args[0].name == arg.name == 'location':
 181             print '    GLint program = -1;'
 182             print '    glGetIntegerv(GL_CURRENT_PROGRAM, &program);'
 183
 184         Retracer.extract_arg(self, function, arg, arg_type, lvalue, rvalue)
 185
 186
 187 if __name__ == '__main__':
 188     print r'''
 189 #include <string.h>
 190 #include <stdio.h>
 191 #include <iostream>
 192
 193 #define RETRACE
 194
 195 #include "glproc.hpp"
 196 #include "glstate.hpp"
 197
 198 #include <GL/glut.h>
 199
 200 static bool double_buffer = false;
 201 static bool insideGlBeginEnd = false;
 202
 203 static int __window_width = 256, __window_height = 256;
 204 bool __reshape_window = false;
 205
 206 unsigned __frame = 0;
 207 long long __startTime = 0;
 208 bool __wait = false;
 209
 210 bool __benchmark = false;
 211 const char *__compare_prefix = NULL;
 212 const char *__snapshot_prefix = NULL;
 213
 214 unsigned __dump_state = ~0;
 215
 216
 217 static void
 218 checkGlError(void) {
 219     if (__benchmark || insideGlBeginEnd) {
 220         return;
 221     }
 222
 223     GLenum error = glGetError();
 224     if (error == GL_NO_ERROR) {
 225         return;
 226     }
 227
 228     std::cerr << "warning: glGetError() = ";
 229     switch (error) {
 230     case GL_INVALID_ENUM:
 231         std::cerr << "GL_INVALID_ENUM";
 232         break;
 233     case GL_INVALID_VALUE:
 234         std::cerr << "GL_INVALID_VALUE";
 235         break;
 236     case GL_INVALID_OPERATION:
 237         std::cerr << "GL_INVALID_OPERATION";
 238         break;
 239     case GL_STACK_OVERFLOW:
 240         std::cerr << "GL_STACK_OVERFLOW";
 241         break;
 242     case GL_STACK_UNDERFLOW:
 243         std::cerr << "GL_STACK_UNDERFLOW";
 244         break;
 245     case GL_OUT_OF_MEMORY:
 246         std::cerr << "GL_OUT_OF_MEMORY";
 247         break;
 248     case GL_INVALID_FRAMEBUFFER_OPERATION:
 249         std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION";
 250         break;
 251     case GL_TABLE_TOO_LARGE:
 252         std::cerr << "GL_TABLE_TOO_LARGE";
 253         break;
 254     default:
 255         std::cerr << error;
 256         break;
 257     }
 258     std::cerr << "\n";
 259 }
 260 '''
 261     api = glapi.glapi
 262     retracer = GlRetracer()
 263     retracer.retrace_api(glapi.glapi)
 264     print r'''
 265
 266 static Trace::Parser parser;
 267
 268 static void display_noop(void) {
 269 }
 270
 271 #include "image.hpp"
 272
 273 static void snapshot(Image::Image &image) {
 274     GLint drawbuffer = double_buffer ? GL_BACK : GL_FRONT;
 275     GLint readbuffer = double_buffer ? GL_BACK : GL_FRONT;
 276     glGetIntegerv(GL_READ_BUFFER, &drawbuffer);
 277     glGetIntegerv(GL_READ_BUFFER, &readbuffer);
 278     glReadBuffer(drawbuffer);
 279     glReadPixels(0, 0, image.width, image.height, GL_RGBA, GL_UNSIGNED_BYTE, image.pixels);
 280     checkGlError();
 281     glReadBuffer(readbuffer);
 282 }
 283
 284 static void frame_complete(void) {
 285     ++__frame;
 286
 287     if (!__reshape_window && (__snapshot_prefix || __compare_prefix)) {
 288         Image::Image *ref = NULL;
 289         if (__compare_prefix) {
 290             char filename[PATH_MAX];
 291             snprintf(filename, sizeof filename, "%s%04u.png", __compare_prefix, __frame);
 292             ref = Image::readPNG(filename);
 293             if (!ref) {
 294                 return;
 295             }
 296             if (verbosity >= 0)
 297                 std::cout << "Read " << filename << "\n";
 298         }
 299
 300         Image::Image src(__window_width, __window_height, true);
 301         snapshot(src);
 302
 303         if (__snapshot_prefix) {
 304             char filename[PATH_MAX];
 305             snprintf(filename, sizeof filename, "%s%04u.png", __snapshot_prefix, __frame);
 306             if (src.writePNG(filename) && verbosity >= 0) {
 307                 std::cout << "Wrote " << filename << "\n";
 308             }
 309         }
 310
 311         if (ref) {
 312             std::cout << "Frame " << __frame << " average precision of " << src.compare(*ref) << " bits\n";
 313             delete ref;
 314         }
 315     }
 316
 317 }
 318
 319 static void display(void) {
 320     Trace::Call *call;
 321
 322     while ((call = parser.parse_call())) {
 323         const std::string &name = call->name();
 324
 325         if (call->no == __dump_state) {
 326             state_dump(std::cout);
 327         }
 328
 329         if ((name[0] == 'w' && name[1] == 'g' && name[2] == 'l') ||
 330             (name[0] == 'g' && name[1] == 'l' && name[2] == 'X')) {
 331             // XXX: We ignore the majority of the OS-specific calls for now
 332             if (name == "glXSwapBuffers" ||
 333                 name == "wglSwapBuffers") {
 334                 if (verbosity >= 1) {
 335                     std::cout << *call;
 336                     std::cout.flush();
 337                 };
 338                 frame_complete();
 339                 if (double_buffer)
 340                     glutSwapBuffers();
 341                 else
 342                     glFlush();
 343
 344                 // Return now to allow GLUT to resize the window.
 345                 delete call;
 346                 return;
 347             } else if (name == "glXMakeCurrent" ||
 348                        name == "wglMakeCurrent") {
 349                 glFlush();
 350                 if (!double_buffer) {
 351                     frame_complete();
 352                     // Return now to allow GLUT to resize window.
 353                     delete call;
 354                     return;
 355                 }
 356             } else {
 357                 continue;
 358             }
 359         }
 360
 361         if (name == "glFlush") {
 362             glFlush();
 363             if (!double_buffer) {
 364                 frame_complete();
 365             }
 366         }
 367
 368         retrace_call(*call);
 369
 370         delete call;
 371     }
 372
 373     // Reached the end of trace
 374     glFlush();
 375
 376     long long endTime = OS::GetTime();
 377     float timeInterval = (endTime - __startTime) * 1.0E-6;
 378
 379     if (verbosity >= -1) {
 380         std::cout <<
 381             "Rendered " << __frame << " frames"
 382             " in " <<  timeInterval << " secs,"
 383             " average of " << (__frame/timeInterval) << " fps\n";
 384     }
 385
 386     if (__wait) {
 387         glutDisplayFunc(&display_noop);
 388         glutIdleFunc(NULL);
 389     } else {
 390         exit(0);
 391     }
 392 }
 393
 394 static void idle(void) {
 395     if (__reshape_window) {
 396         // XXX: doesn't quite work
 397         glutReshapeWindow(__window_width, __window_height);
 398         __reshape_window = false;
 399     }
 400     glutPostRedisplay();
 401 }
 402
 403 static void usage(void) {
 404     std::cout <<
 405         "Usage: glretrace [OPTION] TRACE\n"
 406         "Replay TRACE.\n"
 407         "\n"
 408         "  -b           benchmark (no glgeterror; no messages)\n"
 409         "  -c PREFIX    compare against snapshots\n"
 410         "  -db          use a double buffer visual\n"
 411         "  -s PREFIX    take snapshots\n"
 412         "  -v           verbose output\n"
 413         "  -D CALLNO    dump state at specific call no\n"
 414         "  -w           wait on final frame\n";
 415 }
 416
 417 int main(int argc, char **argv)
 418 {
 419
 420     int i;
 421     for (i = 1; i < argc; ++i) {
 422         const char *arg = argv[i];
 423
 424         if (arg[0] != '-') {
 425             break;
 426         }
 427
 428         if (!strcmp(arg, "--")) {
 429             break;
 430         } else if (!strcmp(arg, "-b")) {
 431             __benchmark = true;
 432             verbosity = -1;
 433         } else if (!strcmp(arg, "-c")) {
 434             __compare_prefix = argv[++i];
 435         } else if (!strcmp(arg, "-D")) {
 436             __dump_state = atoi(argv[++i]);
 437             verbosity = -2;
 438         } else if (!strcmp(arg, "-db")) {
 439             double_buffer = true;
 440         } else if (!strcmp(arg, "--help")) {
 441             usage();
 442             return 0;
 443         } else if (!strcmp(arg, "-s")) {
 444             __snapshot_prefix = argv[++i];
 445         } else if (!strcmp(arg, "-v")) {
 446             ++verbosity;
 447         } else if (!strcmp(arg, "-w")) {
 448             __wait = true;
 449         } else {
 450             std::cerr << "error: unknown option " << arg << "\n";
 451             usage();
 452             return 1;
 453         }
 454     }
 455
 456     glutInit(&argc, argv);
 457     glutInitWindowPosition(0, 0);
 458     glutInitWindowSize(__window_width, __window_height);
 459     glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | (double_buffer ? GLUT_DOUBLE : GLUT_SINGLE));
 460     glutCreateWindow(argv[0]);
 461
 462     glutDisplayFunc(&display);
 463     glutIdleFunc(&idle);
 464
 465     for (GLuint h = 0; h < 1024; ++h) {
 466         __list_map[h] = h;
 467     }
 468
 469     for ( ; i < argc; ++i) {
 470         if (parser.open(argv[i])) {
 471             __startTime = OS::GetTime();
 472             glutMainLoop();
 473             parser.close();
 474         }
 475     }
 476
 477     return 0;
 478 }
 479
 480 '''