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 #include "glproc.hpp"
 171 #include "glstate.hpp"
 172
 173 #include <GL/glut.h>
 174
 175 static bool double_buffer = false;
 176 static bool insideGlBeginEnd = false;
 177
 178 static int __window_width = 256, __window_height = 256;
 179 bool __reshape_window = false;
 180
 181 unsigned __frame = 0;
 182 long long __startTime = 0;
 183 bool __wait = false;
 184
 185 bool __benchmark = false;
 186 const char *__compare_prefix = NULL;
 187 const char *__snapshot_prefix = NULL;
 188
 189 unsigned __dump_state = ~0;
 190
 191
 192 static void
 193 checkGlError(void) {
 194     if (__benchmark || insideGlBeginEnd) {
 195         return;
 196     }
 197
 198     GLenum error = glGetError();
 199     if (error == GL_NO_ERROR) {
 200         return;
 201     }
 202
 203     std::cerr << "warning: glGetError() = ";
 204     switch (error) {
 205     case GL_INVALID_ENUM:
 206         std::cerr << "GL_INVALID_ENUM";
 207         break;
 208     case GL_INVALID_VALUE:
 209         std::cerr << "GL_INVALID_VALUE";
 210         break;
 211     case GL_INVALID_OPERATION:
 212         std::cerr << "GL_INVALID_OPERATION";
 213         break;
 214     case GL_STACK_OVERFLOW:
 215         std::cerr << "GL_STACK_OVERFLOW";
 216         break;
 217     case GL_STACK_UNDERFLOW:
 218         std::cerr << "GL_STACK_UNDERFLOW";
 219         break;
 220     case GL_OUT_OF_MEMORY:
 221         std::cerr << "GL_OUT_OF_MEMORY";
 222         break;
 223     case GL_INVALID_FRAMEBUFFER_OPERATION:
 224         std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION";
 225         break;
 226     case GL_TABLE_TOO_LARGE:
 227         std::cerr << "GL_TABLE_TOO_LARGE";
 228         break;
 229     default:
 230         std::cerr << error;
 231         break;
 232     }
 233     std::cerr << "\n";
 234 }
 235 '''
 236     api = glapi.glapi
 237     retracer = GlRetracer()
 238     retracer.retrace_api(glapi.glapi)
 239     print r'''
 240
 241 static Trace::Parser parser;
 242
 243 static void display_noop(void) {
 244 }
 245
 246 #include "image.hpp"
 247
 248 static void snapshot(Image::Image &image) {
 249     GLint drawbuffer = double_buffer ? GL_BACK : GL_FRONT;
 250     GLint readbuffer = double_buffer ? GL_BACK : GL_FRONT;
 251     glGetIntegerv(GL_READ_BUFFER, &drawbuffer);
 252     glGetIntegerv(GL_READ_BUFFER, &readbuffer);
 253     glReadBuffer(drawbuffer);
 254     glReadPixels(0, 0, image.width, image.height, GL_RGBA, GL_UNSIGNED_BYTE, image.pixels);
 255     checkGlError();
 256     glReadBuffer(readbuffer);
 257 }
 258
 259 static void frame_complete(void) {
 260     ++__frame;
 261
 262     if (!__reshape_window && (__snapshot_prefix || __compare_prefix)) {
 263         Image::Image *ref = NULL;
 264         if (__compare_prefix) {
 265             char filename[PATH_MAX];
 266             snprintf(filename, sizeof filename, "%s%04u.png", __compare_prefix, __frame);
 267             ref = Image::readPNG(filename);
 268             if (!ref) {
 269                 return;
 270             }
 271             if (verbosity >= 0)
 272                 std::cout << "Read " << filename << "\n";
 273         }
 274
 275         Image::Image src(__window_width, __window_height, true);
 276         snapshot(src);
 277
 278         if (__snapshot_prefix) {
 279             char filename[PATH_MAX];
 280             snprintf(filename, sizeof filename, "%s%04u.png", __snapshot_prefix, __frame);
 281             if (src.writePNG(filename) && verbosity >= 0) {
 282                 std::cout << "Wrote " << filename << "\n";
 283             }
 284         }
 285
 286         if (ref) {
 287             std::cout << "Frame " << __frame << " average precision of " << src.compare(*ref) << " bits\n";
 288             delete ref;
 289         }
 290     }
 291
 292 }
 293
 294 static void display(void) {
 295     Trace::Call *call;
 296
 297     while ((call = parser.parse_call())) {
 298         const std::string &name = call->name();
 299
 300         if (call->no == __dump_state) {
 301             state_dump(std::cout);
 302             exit(0);
 303         }
 304
 305         if ((name[0] == 'w' && name[1] == 'g' && name[2] == 'l') ||
 306             (name[0] == 'g' && name[1] == 'l' && name[2] == 'X')) {
 307             // XXX: We ignore the majority of the OS-specific calls for now
 308             if (name == "glXSwapBuffers" ||
 309                 name == "wglSwapBuffers") {
 310                 if (verbosity >= 1) {
 311                     std::cout << *call;
 312                     std::cout.flush();
 313                 };
 314                 frame_complete();
 315                 if (double_buffer)
 316                     glutSwapBuffers();
 317                 else
 318                     glFlush();
 319
 320                 // Return now to allow GLUT to resize the window.
 321                 delete call;
 322                 return;
 323             } else if (name == "glXMakeCurrent" ||
 324                        name == "wglMakeCurrent") {
 325                 glFlush();
 326                 if (!double_buffer) {
 327                     frame_complete();
 328                     // Return now to allow GLUT to resize window.
 329                     delete call;
 330                     return;
 331                 }
 332             } else {
 333                 continue;
 334             }
 335         }
 336
 337         if (name == "glFlush") {
 338             glFlush();
 339             if (!double_buffer) {
 340                 frame_complete();
 341             }
 342         }
 343
 344         retrace_call(*call);
 345
 346         delete call;
 347     }
 348
 349     // Reached the end of trace
 350     glFlush();
 351
 352     long long endTime = OS::GetTime();
 353     float timeInterval = (endTime - __startTime) * 1.0E-6;
 354
 355     if (verbosity >= -1) {
 356         std::cout <<
 357             "Rendered " << __frame << " frames"
 358             " in " <<  timeInterval << " secs,"
 359             " average of " << (__frame/timeInterval) << " fps\n";
 360     }
 361
 362     if (__wait) {
 363         glutDisplayFunc(&display_noop);
 364         glutIdleFunc(NULL);
 365     } else {
 366         exit(0);
 367     }
 368 }
 369
 370 static void idle(void) {
 371     if (__reshape_window) {
 372         // XXX: doesn't quite work
 373         glutReshapeWindow(__window_width, __window_height);
 374         __reshape_window = false;
 375     }
 376     glutPostRedisplay();
 377 }
 378
 379 static void usage(void) {
 380     std::cout <<
 381         "Usage: glretrace [OPTION] TRACE\n"
 382         "Replay TRACE.\n"
 383         "\n"
 384         "  -b           benchmark (no glgeterror; no messages)\n"
 385         "  -c PREFIX    compare against snapshots\n"
 386         "  -db          use a double buffer visual\n"
 387         "  -s PREFIX    take snapshots\n"
 388         "  -v           verbose output\n"
 389         "  -D CALLNO    dump state at specific call no\n"
 390         "  -w           wait on final frame\n";
 391 }
 392
 393 int main(int argc, char **argv)
 394 {
 395
 396     int i;
 397     for (i = 1; i < argc; ++i) {
 398         const char *arg = argv[i];
 399
 400         if (arg[0] != '-') {
 401             break;
 402         }
 403
 404         if (!strcmp(arg, "--")) {
 405             break;
 406         } else if (!strcmp(arg, "-b")) {
 407             __benchmark = true;
 408             verbosity = -1;
 409         } else if (!strcmp(arg, "-c")) {
 410             __compare_prefix = argv[++i];
 411         } else if (!strcmp(arg, "-D")) {
 412             __dump_state = atoi(argv[++i]);
 413             verbosity = -2;
 414         } else if (!strcmp(arg, "-db")) {
 415             double_buffer = true;
 416         } else if (!strcmp(arg, "--help")) {
 417             usage();
 418             return 0;
 419         } else if (!strcmp(arg, "-s")) {
 420             __snapshot_prefix = argv[++i];
 421         } else if (!strcmp(arg, "-v")) {
 422             ++verbosity;
 423         } else if (!strcmp(arg, "-w")) {
 424             __wait = true;
 425         } else {
 426             std::cerr << "error: unknown option " << arg << "\n";
 427             usage();
 428             return 1;
 429         }
 430     }
 431
 432     glutInit(&argc, argv);
 433     glutInitWindowPosition(0, 0);
 434     glutInitWindowSize(__window_width, __window_height);
 435     glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | (double_buffer ? GLUT_DOUBLE : GLUT_SINGLE));
 436     glutCreateWindow(argv[0]);
 437
 438     glutDisplayFunc(&display);
 439     glutIdleFunc(&idle);
 440
 441     for ( ; i < argc; ++i) {
 442         if (parser.open(argv[i])) {
 443             __startTime = OS::GetTime();
 444             glutMainLoop();
 445             parser.close();
 446         }
 447     }
 448
 449     return 0;
 450 }
 451
 452 '''