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 #include "glws.hpp"
 175
 176 static bool double_buffer = false;
 177 static bool insideGlBeginEnd = false;
 178
 179 static int __window_width = 256, __window_height = 256;
 180 bool __reshape_window = false;
 181
 182 unsigned __frame = 0;
 183 long long __startTime = 0;
 184 bool __wait = false;
 185
 186 bool __benchmark = false;
 187 const char *__compare_prefix = NULL;
 188 const char *__snapshot_prefix = NULL;
 189
 190 unsigned __dump_state = ~0;
 191
 192
 193 static void
 194 checkGlError(void) {
 195     if (__benchmark || insideGlBeginEnd) {
 196         return;
 197     }
 198
 199     GLenum error = glGetError();
 200     if (error == GL_NO_ERROR) {
 201         return;
 202     }
 203
 204     std::cerr << "warning: glGetError() = ";
 205     switch (error) {
 206     case GL_INVALID_ENUM:
 207         std::cerr << "GL_INVALID_ENUM";
 208         break;
 209     case GL_INVALID_VALUE:
 210         std::cerr << "GL_INVALID_VALUE";
 211         break;
 212     case GL_INVALID_OPERATION:
 213         std::cerr << "GL_INVALID_OPERATION";
 214         break;
 215     case GL_STACK_OVERFLOW:
 216         std::cerr << "GL_STACK_OVERFLOW";
 217         break;
 218     case GL_STACK_UNDERFLOW:
 219         std::cerr << "GL_STACK_UNDERFLOW";
 220         break;
 221     case GL_OUT_OF_MEMORY:
 222         std::cerr << "GL_OUT_OF_MEMORY";
 223         break;
 224     case GL_INVALID_FRAMEBUFFER_OPERATION:
 225         std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION";
 226         break;
 227     case GL_TABLE_TOO_LARGE:
 228         std::cerr << "GL_TABLE_TOO_LARGE";
 229         break;
 230     default:
 231         std::cerr << error;
 232         break;
 233     }
 234     std::cerr << "\n";
 235 }
 236 '''
 237     api = glapi.glapi
 238     retracer = GlRetracer()
 239     retracer.retrace_api(glapi.glapi)
 240     print r'''
 241
 242 static Trace::Parser parser;
 243 static glws::WindowSystem *__ws = NULL;
 244 static glws::Visual *__visual = NULL;
 245 static glws::Drawable *__drawable = NULL;
 246 static glws::Context *__context = NULL;
 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     if (__reshape_window) {
 295         // XXX: doesn't quite work
 296         __drawable->resize(__window_width, __window_height);
 297         __reshape_window = false;
 298     }
 299
 300     __ws->processEvents();
 301 }
 302
 303 static void display(void) {
 304     Trace::Call *call;
 305
 306     while ((call = parser.parse_call())) {
 307         const std::string &name = call->name();
 308
 309         if (call->no == __dump_state) {
 310             state_dump(std::cout);
 311             exit(0);
 312         }
 313
 314         if ((name[0] == 'w' && name[1] == 'g' && name[2] == 'l') ||
 315             (name[0] == 'g' && name[1] == 'l' && name[2] == 'X')) {
 316             // XXX: We ignore the majority of the OS-specific calls for now
 317             if (name == "glXSwapBuffers" ||
 318                 name == "wglSwapBuffers") {
 319                 if (verbosity >= 1) {
 320                     std::cout << *call;
 321                     std::cout.flush();
 322                 };
 323                 frame_complete();
 324                 if (double_buffer)
 325                     __drawable->swapBuffers();
 326                 else
 327                     glFlush();
 328             } else if (name == "glXMakeCurrent" ||
 329                        name == "wglMakeCurrent") {
 330                 glFlush();
 331                 if (!double_buffer) {
 332                     frame_complete();
 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         while (__ws->processEvents()) {}
 366     } else {
 367         exit(0);
 368     }
 369 }
 370
 371 static void usage(void) {
 372     std::cout <<
 373         "Usage: glretrace [OPTION] TRACE\n"
 374         "Replay TRACE.\n"
 375         "\n"
 376         "  -b           benchmark (no glgeterror; no messages)\n"
 377         "  -c PREFIX    compare against snapshots\n"
 378         "  -db          use a double buffer visual\n"
 379         "  -s PREFIX    take snapshots\n"
 380         "  -v           verbose output\n"
 381         "  -D CALLNO    dump state at specific call no\n"
 382         "  -w           wait on final frame\n";
 383 }
 384
 385 int main(int argc, char **argv)
 386 {
 387
 388     int i;
 389     for (i = 1; i < argc; ++i) {
 390         const char *arg = argv[i];
 391
 392         if (arg[0] != '-') {
 393             break;
 394         }
 395
 396         if (!strcmp(arg, "--")) {
 397             break;
 398         } else if (!strcmp(arg, "-b")) {
 399             __benchmark = true;
 400             verbosity = -1;
 401         } else if (!strcmp(arg, "-c")) {
 402             __compare_prefix = argv[++i];
 403         } else if (!strcmp(arg, "-D")) {
 404             __dump_state = atoi(argv[++i]);
 405             verbosity = -2;
 406         } else if (!strcmp(arg, "-db")) {
 407             double_buffer = true;
 408         } else if (!strcmp(arg, "--help")) {
 409             usage();
 410             return 0;
 411         } else if (!strcmp(arg, "-s")) {
 412             __snapshot_prefix = argv[++i];
 413         } else if (!strcmp(arg, "-v")) {
 414             ++verbosity;
 415         } else if (!strcmp(arg, "-w")) {
 416             __wait = true;
 417         } else {
 418             std::cerr << "error: unknown option " << arg << "\n";
 419             usage();
 420             return 1;
 421         }
 422     }
 423
 424     __ws = glws::createNativeWindowSystem();
 425     __visual = __ws->createVisual(double_buffer);
 426     __drawable = __ws->createDrawable(__visual);
 427     __drawable->resize(__window_width, __window_height);
 428     __context = __ws->createContext(__visual);
 429     __ws->makeCurrent(__drawable, __context);
 430
 431     for (GLuint h = 0; h < 1024; ++h) {
 432         __list_map[h] = h;
 433     }
 434
 435     for ( ; i < argc; ++i) {
 436         if (parser.open(argv[i])) {
 437             __startTime = OS::GetTime();
 438             display();
 439             parser.close();
 440         }
 441     }
 442
 443     return 0;
 444 }
 445
 446 '''