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