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