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         "glVertexAttribLPointerEXT",
  66
  67         #"glMatrixIndexPointerARB",
  68     ))
  69
  70     draw_array_function_names = set([
  71         "glDrawArrays",
  72         "glDrawArraysEXT",
  73         "glDrawArraysIndirect",
  74         "glDrawArraysInstanced",
  75         "glDrawArraysInstancedARB",
  76         "glDrawArraysInstancedEXT",
  77         "glDrawMeshArraysSUN",
  78         "glMultiDrawArrays",
  79         "glMultiDrawArraysEXT",
  80         "glMultiModeDrawArraysIBM",
  81     ])
  82
  83     draw_elements_function_names = set([
  84         "glDrawElements",
  85         "glDrawElementsBaseVertex",
  86         "glDrawElementsIndirect",
  87         "glDrawElementsInstanced",
  88         "glDrawElementsInstancedARB",
  89         "glDrawElementsInstancedBaseVertex",
  90         "glDrawElementsInstancedEXT",
  91         "glDrawRangeElements",
  92         "glDrawRangeElementsBaseVertex",
  93         "glDrawRangeElementsEXT",
  94         #"glMultiDrawElements",
  95         #"glMultiDrawElementsBaseVertex",
  96         #"glMultiDrawElementsEXT",
  97         #"glMultiModeDrawElementsIBM",
  98     ])
  99
 100     def retrace_function_body(self, function):
 101         is_array_pointer = function.name in self.array_pointer_function_names
 102         is_draw_array = function.name in self.draw_array_function_names
 103         is_draw_elements = function.name in self.draw_elements_function_names
 104
 105         if is_array_pointer or is_draw_array or is_draw_elements:
 106             print '    if (Trace::Parser::version < 1) {'
 107
 108             if is_array_pointer or is_draw_array:
 109                 print '        GLint __array_buffer = 0;'
 110                 print '        glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 111                 print '        if (!__array_buffer) {'
 112                 self.fail_function(function)
 113                 print '        }'
 114
 115             if is_draw_elements:
 116                 print '        GLint __element_array_buffer = 0;'
 117                 print '        glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
 118                 print '        if (!__element_array_buffer) {'
 119                 self.fail_function(function)
 120                 print '        }'
 121
 122             print '    }'
 123
 124         Retracer.retrace_function_body(self, function)
 125
 126     def call_function(self, function):
 127         if function.name == "glViewport":
 128             print '    if (x + width > __window_width) {'
 129             print '        __window_width = x + width;'
 130             print '        __reshape_window = true;'
 131             print '    }'
 132             print '    if (y + height > __window_height) {'
 133             print '        __window_height = y + height;'
 134             print '        __reshape_window = true;'
 135             print '    }'
 136
 137         if function.name == "glEnd":
 138             print '    insideGlBeginEnd = false;'
 139
 140         Retracer.call_function(self, function)
 141
 142         if function.name == "glBegin":
 143             print '    insideGlBeginEnd = true;'
 144         else:
 145             # glGetError is not allowed inside glBegin/glEnd
 146             print '    checkGlError();'
 147
 148     def extract_arg(self, function, arg, arg_type, lvalue, rvalue):
 149         if function.name in self.array_pointer_function_names and arg.name == 'pointer':
 150             print '    %s = %s.blob();' % (lvalue, rvalue)
 151             return
 152
 153         if function.name in self.draw_elements_function_names and arg.name == 'indices':
 154             print '    %s = %s.blob();' % (lvalue, rvalue)
 155             return
 156
 157         if function.name.startswith('glUniform') and function.args[0].name == arg.name == 'location':
 158             print '    GLint program = -1;'
 159             print '    glGetIntegerv(GL_CURRENT_PROGRAM, &program);'
 160
 161         Retracer.extract_arg(self, function, arg, arg_type, lvalue, rvalue)
 162
 163
 164 if __name__ == '__main__':
 165     print r'''
 166 #include <string.h>
 167 #include <stdio.h>
 168 #include <iostream>
 169
 170 #define RETRACE
 171
 172 #include "glproc.hpp"
 173 #include "glstate.hpp"
 174
 175 #include <GL/glut.h>
 176
 177 static bool double_buffer = false;
 178 static bool insideGlBeginEnd = false;
 179
 180 static int __window_width = 256, __window_height = 256;
 181 bool __reshape_window = false;
 182
 183 unsigned __frame = 0;
 184 long long __startTime = 0;
 185 bool __wait = false;
 186
 187 bool __benchmark = false;
 188 const char *__compare_prefix = NULL;
 189 const char *__snapshot_prefix = NULL;
 190
 191 unsigned __dump_state = ~0;
 192
 193
 194 static void
 195 checkGlError(void) {
 196     if (__benchmark || insideGlBeginEnd) {
 197         return;
 198     }
 199
 200     GLenum error = glGetError();
 201     if (error == GL_NO_ERROR) {
 202         return;
 203     }
 204
 205     std::cerr << "warning: glGetError() = ";
 206     switch (error) {
 207     case GL_INVALID_ENUM:
 208         std::cerr << "GL_INVALID_ENUM";
 209         break;
 210     case GL_INVALID_VALUE:
 211         std::cerr << "GL_INVALID_VALUE";
 212         break;
 213     case GL_INVALID_OPERATION:
 214         std::cerr << "GL_INVALID_OPERATION";
 215         break;
 216     case GL_STACK_OVERFLOW:
 217         std::cerr << "GL_STACK_OVERFLOW";
 218         break;
 219     case GL_STACK_UNDERFLOW:
 220         std::cerr << "GL_STACK_UNDERFLOW";
 221         break;
 222     case GL_OUT_OF_MEMORY:
 223         std::cerr << "GL_OUT_OF_MEMORY";
 224         break;
 225     case GL_INVALID_FRAMEBUFFER_OPERATION:
 226         std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION";
 227         break;
 228     case GL_TABLE_TOO_LARGE:
 229         std::cerr << "GL_TABLE_TOO_LARGE";
 230         break;
 231     default:
 232         std::cerr << error;
 233         break;
 234     }
 235     std::cerr << "\n";
 236 }
 237 '''
 238     api = glapi.glapi
 239     retracer = GlRetracer()
 240     retracer.retrace_api(glapi.glapi)
 241     print r'''
 242
 243 static Trace::Parser parser;
 244
 245 static void display_noop(void) {
 246 }
 247
 248 #include "image.hpp"
 249
 250 static void snapshot(Image::Image &image) {
 251     GLint drawbuffer = double_buffer ? GL_BACK : GL_FRONT;
 252     GLint readbuffer = double_buffer ? GL_BACK : GL_FRONT;
 253     glGetIntegerv(GL_READ_BUFFER, &drawbuffer);
 254     glGetIntegerv(GL_READ_BUFFER, &readbuffer);
 255     glReadBuffer(drawbuffer);
 256     glReadPixels(0, 0, image.width, image.height, GL_RGBA, GL_UNSIGNED_BYTE, image.pixels);
 257     checkGlError();
 258     glReadBuffer(readbuffer);
 259 }
 260
 261 static void frame_complete(void) {
 262     ++__frame;
 263
 264     if (!__reshape_window && (__snapshot_prefix || __compare_prefix)) {
 265         Image::Image *ref = NULL;
 266         if (__compare_prefix) {
 267             char filename[PATH_MAX];
 268             snprintf(filename, sizeof filename, "%s%04u.png", __compare_prefix, __frame);
 269             ref = Image::readPNG(filename);
 270             if (!ref) {
 271                 return;
 272             }
 273             if (verbosity >= 0)
 274                 std::cout << "Read " << filename << "\n";
 275         }
 276
 277         Image::Image src(__window_width, __window_height, true);
 278         snapshot(src);
 279
 280         if (__snapshot_prefix) {
 281             char filename[PATH_MAX];
 282             snprintf(filename, sizeof filename, "%s%04u.png", __snapshot_prefix, __frame);
 283             if (src.writePNG(filename) && verbosity >= 0) {
 284                 std::cout << "Wrote " << filename << "\n";
 285             }
 286         }
 287
 288         if (ref) {
 289             std::cout << "Frame " << __frame << " average precision of " << src.compare(*ref) << " bits\n";
 290             delete ref;
 291         }
 292     }
 293
 294 }
 295
 296 static void display(void) {
 297     Trace::Call *call;
 298
 299     while ((call = parser.parse_call())) {
 300         const std::string &name = call->name();
 301
 302         if (call->no == __dump_state) {
 303             state_dump(std::cout);
 304             exit(0);
 305         }
 306
 307         if ((name[0] == 'w' && name[1] == 'g' && name[2] == 'l') ||
 308             (name[0] == 'g' && name[1] == 'l' && name[2] == 'X')) {
 309             // XXX: We ignore the majority of the OS-specific calls for now
 310             if (name == "glXSwapBuffers" ||
 311                 name == "wglSwapBuffers") {
 312                 if (verbosity >= 1) {
 313                     std::cout << *call;
 314                     std::cout.flush();
 315                 };
 316                 frame_complete();
 317                 if (double_buffer)
 318                     glutSwapBuffers();
 319                 else
 320                     glFlush();
 321
 322                 // Return now to allow GLUT to resize the window.
 323                 delete call;
 324                 return;
 325             } else if (name == "glXMakeCurrent" ||
 326                        name == "wglMakeCurrent") {
 327                 glFlush();
 328                 if (!double_buffer) {
 329                     frame_complete();
 330                     // Return now to allow GLUT to resize window.
 331                     delete call;
 332                     return;
 333                 }
 334             } else {
 335                 continue;
 336             }
 337         }
 338
 339         if (name == "glFlush") {
 340             glFlush();
 341             if (!double_buffer) {
 342                 frame_complete();
 343             }
 344         }
 345
 346         retrace_call(*call);
 347
 348         delete call;
 349     }
 350
 351     // Reached the end of trace
 352     glFlush();
 353
 354     long long endTime = OS::GetTime();
 355     float timeInterval = (endTime - __startTime) * 1.0E-6;
 356
 357     if (verbosity >= -1) {
 358         std::cout <<
 359             "Rendered " << __frame << " frames"
 360             " in " <<  timeInterval << " secs,"
 361             " average of " << (__frame/timeInterval) << " fps\n";
 362     }
 363
 364     if (__wait) {
 365         glutDisplayFunc(&display_noop);
 366         glutIdleFunc(NULL);
 367     } else {
 368         exit(0);
 369     }
 370 }
 371
 372 static void idle(void) {
 373     if (__reshape_window) {
 374         // XXX: doesn't quite work
 375         glutReshapeWindow(__window_width, __window_height);
 376         __reshape_window = false;
 377     }
 378     glutPostRedisplay();
 379 }
 380
 381 static void usage(void) {
 382     std::cout <<
 383         "Usage: glretrace [OPTION] TRACE\n"
 384         "Replay TRACE.\n"
 385         "\n"
 386         "  -b           benchmark (no glgeterror; no messages)\n"
 387         "  -c PREFIX    compare against snapshots\n"
 388         "  -db          use a double buffer visual\n"
 389         "  -s PREFIX    take snapshots\n"
 390         "  -v           verbose output\n"
 391         "  -D CALLNO    dump state at specific call no\n"
 392         "  -w           wait on final frame\n";
 393 }
 394
 395 int main(int argc, char **argv)
 396 {
 397
 398     int i;
 399     for (i = 1; i < argc; ++i) {
 400         const char *arg = argv[i];
 401
 402         if (arg[0] != '-') {
 403             break;
 404         }
 405
 406         if (!strcmp(arg, "--")) {
 407             break;
 408         } else if (!strcmp(arg, "-b")) {
 409             __benchmark = true;
 410             verbosity = -1;
 411         } else if (!strcmp(arg, "-c")) {
 412             __compare_prefix = argv[++i];
 413         } else if (!strcmp(arg, "-D")) {
 414             __dump_state = atoi(argv[++i]);
 415             verbosity = -2;
 416         } else if (!strcmp(arg, "-db")) {
 417             double_buffer = true;
 418         } else if (!strcmp(arg, "--help")) {
 419             usage();
 420             return 0;
 421         } else if (!strcmp(arg, "-s")) {
 422             __snapshot_prefix = argv[++i];
 423         } else if (!strcmp(arg, "-v")) {
 424             ++verbosity;
 425         } else if (!strcmp(arg, "-w")) {
 426             __wait = true;
 427         } else {
 428             std::cerr << "error: unknown option " << arg << "\n";
 429             usage();
 430             return 1;
 431         }
 432     }
 433
 434     glutInit(&argc, argv);
 435     glutInitWindowPosition(0, 0);
 436     glutInitWindowSize(__window_width, __window_height);
 437     glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | (double_buffer ? GLUT_DOUBLE : GLUT_SINGLE));
 438     glutCreateWindow(argv[0]);
 439
 440     glutDisplayFunc(&display);
 441     glutIdleFunc(&idle);
 442
 443     for (GLuint h = 0; h < 1024; ++h) {
 444         __list_map[h] = h;
 445     }
 446
 447     for ( ; i < argc; ++i) {
 448         if (parser.open(argv[i])) {
 449             __startTime = OS::GetTime();
 450             glutMainLoop();
 451             parser.close();
 452         }
 453     }
 454
 455     return 0;
 456 }
 457
 458 '''