git.cworth.org Git - fips/blob - glwrap.c

   1 /* Copyright © 2013, Intel Corporation
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to deal
   5  * in the Software without restriction, including without limitation the rights
   6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   7  * copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  19  * THE SOFTWARE.
  20  */
  21
  22 /* The prototypes for some OpenGL functions changed at one point from:
  23  *
  24  *      const void* *indices
  25  * to:
  26  *      const void* const coist *indices
  27  *
  28  * This makes it difficult for us to provide an implementation of
  29  * these functions that is consistent with the locally-available gl.h
  30  * since we don't know if the extra const will be present or not.
  31  *
  32  * To workaround this problem, we simply #define away const altogether
  33  * before including gl.h.
  34  *
  35  * Kudos to Keith Packard for suggesting this kludge.
  36  */
  37 #define const
  38
  39 #include "fips.h"
  40 #include "fips-dispatch.h"
  41
  42 #include "glwrap.h"
  43
  44 #include "metrics.h"
  45
  46 #include "dlwrap.h"
  47
  48 static int inside_new_list = 0;
  49
  50 void *
  51 glwrap_lookup (char *name)
  52 {
  53         const char *libgl_filename = "libGL.so.1";
  54         static void *libgl_handle = NULL;
  55
  56         if (! libgl_handle) {
  57                 libgl_handle = dlwrap_real_dlopen (libgl_filename, RTLD_NOW | RTLD_DEEPBIND);
  58                 if (! libgl_handle) {
  59                         fprintf (stderr, "Error: Failed to dlopen %s\n",
  60                                  libgl_filename);
  61                         exit (1);
  62                 }
  63         }
  64
  65         return dlwrap_real_dlsym (libgl_handle, name);
  66 }
  67
  68 /* Execute a glBeginQuery/glEndQuery pair around an OpenGL call. */
  69 #define TIMED_DEFER(function,...) do {                                  \
  70         if (! inside_new_list) {                                        \
  71                 unsigned counter;                                       \
  72                 counter = metrics_add_counter ();                       \
  73                 glBeginQuery (GL_TIME_ELAPSED, counter);                \
  74         }                                                               \
  75         GLWRAP_DEFER(function, __VA_ARGS__);                            \
  76         if (! inside_new_list) {                                        \
  77                 glEndQuery (GL_TIME_ELAPSED);                           \
  78         }                                                               \
  79 } while (0);
  80
  81 /* Thanks to apitrace source code for the list of OpenGL draw calls. */
  82 void
  83 glDrawArrays (GLenum mode, GLint first, GLsizei count)
  84 {
  85         TIMED_DEFER (glDrawArrays, mode, first, count);
  86 }
  87
  88 void
  89 glDrawArraysEXT (GLenum mode, GLint first, GLsizei count)
  90 {
  91         TIMED_DEFER (glDrawArraysEXT, mode, first, count);
  92 }
  93
  94 void
  95 glDrawArraysIndirect (GLenum mode, const GLvoid *indirect)
  96 {
  97         TIMED_DEFER (glDrawArraysIndirect, mode, indirect);
  98 }
  99
 100 void
 101 glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count,
 102                        GLsizei primcount)
 103 {
 104         TIMED_DEFER (glDrawArraysInstanced, mode, first, count, primcount);
 105 }
 106
 107 void
 108 glDrawArraysInstancedARB (GLenum mode, GLint first, GLsizei count,
 109                           GLsizei primcount)
 110 {
 111         TIMED_DEFER (glDrawArraysInstancedARB, mode, first, count, primcount);
 112 }
 113
 114 void
 115 glDrawArraysInstancedEXT (GLenum mode, GLint start, GLsizei count,
 116                           GLsizei primcount)
 117 {
 118         TIMED_DEFER (glDrawArraysInstancedEXT, mode, start, count, primcount);
 119 }
 120
 121 void
 122 glDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count,
 123                                    GLsizei primcount, GLuint baseinstance)
 124 {
 125         TIMED_DEFER (glDrawArraysInstancedBaseInstance, mode,
 126                      first, count, primcount, baseinstance);
 127 }
 128
 129 void
 130 glDrawMeshArraysSUN (GLenum mode, GLint first, GLsizei count, GLsizei width)
 131 {
 132         TIMED_DEFER (glDrawMeshArraysSUN, mode, first, count, width);
 133 }
 134
 135 void
 136 glMultiDrawArrays (GLenum mode, const GLint *first,
 137                    const GLsizei *count, GLsizei primcount)
 138 {
 139         TIMED_DEFER (glMultiDrawArrays, mode, first, count, primcount);
 140 }
 141
 142 void
 143 glMultiDrawArraysEXT (GLenum mode, const GLint *first,
 144                       const GLsizei *count, GLsizei primcount)
 145 {
 146         TIMED_DEFER (glMultiDrawArraysEXT, mode, first, count, primcount);
 147 }
 148
 149 void
 150 glMultiModeDrawArraysIBM (const GLenum *mode, const GLint *first,
 151                           const GLsizei *count, GLsizei primcount,
 152                           GLint modestride)
 153 {
 154         TIMED_DEFER (glMultiModeDrawArraysIBM, mode,
 155                      first, count, primcount, modestride);
 156 }
 157
 158 void
 159 glMultiDrawArraysIndirect (GLenum mode, const void *indirect,
 160                            GLsizei drawcount, GLsizei stride)
 161 {
 162         TIMED_DEFER (glMultiDrawArraysIndirect, mode, indirect, drawcount, stride);
 163 }
 164
 165 void
 166 glMultiDrawArraysIndirectAMD (GLenum mode, const GLvoid *indirect,
 167                               GLsizei primcount, GLsizei stride)
 168 {
 169         TIMED_DEFER (glMultiDrawArraysIndirectAMD, mode,
 170                      indirect, primcount, stride);
 171 }
 172
 173 void
 174 glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 175 {
 176         TIMED_DEFER (glDrawElements, mode, count, type, indices);
 177 }
 178
 179 void
 180 glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type,
 181                           const GLvoid *indices, GLint basevertex)
 182 {
 183         TIMED_DEFER (glDrawElementsBaseVertex, mode, count,
 184                      type, indices, basevertex);
 185 }
 186
 187 void
 188 glDrawElementsIndirect (GLenum mode, GLenum type, const GLvoid *indirect)
 189 {
 190         TIMED_DEFER (glDrawElementsIndirect, mode, type, indirect);
 191 }
 192
 193 void
 194 glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type,
 195                          const GLvoid *indices, GLsizei primcount)
 196 {
 197         TIMED_DEFER (glDrawElementsInstanced, mode, count,
 198                      type, indices, primcount);
 199 }
 200
 201 void
 202 glDrawElementsInstancedARB (GLenum mode, GLsizei count, GLenum type,
 203                             const GLvoid *indices, GLsizei primcount)
 204 {
 205         TIMED_DEFER (glDrawElementsInstancedARB, mode, count,
 206                      type, indices, primcount);
 207 }
 208
 209 void
 210 glDrawElementsInstancedEXT (GLenum mode, GLsizei count, GLenum type,
 211                             const GLvoid *indices, GLsizei primcount)
 212 {
 213         TIMED_DEFER (glDrawElementsInstancedEXT, mode, count,
 214                      type, indices, primcount);
 215 }
 216
 217 void
 218 glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type,
 219                                    const GLvoid *indices, GLsizei primcount,
 220                                    GLint basevertex)
 221 {
 222         TIMED_DEFER (glDrawElementsInstancedBaseVertex, mode, count,
 223                      type, indices, primcount, basevertex);
 224 }
 225
 226 void
 227 glDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type,
 228                                      const void *indices, GLsizei primcount,
 229                                      GLuint baseinstance)
 230 {
 231         TIMED_DEFER (glDrawElementsInstancedBaseInstance, mode, count, type,
 232                      indices, primcount, baseinstance);
 233 }
 234
 235 void
 236 glDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count,
 237                       GLenum type, const void *indices, GLsizei primcount,
 238                       GLint basevertex, GLuint baseinstance)
 239 {
 240         TIMED_DEFER (glDrawElementsInstancedBaseVertexBaseInstance, mode,
 241                      count, type, indices, primcount, basevertex, baseinstance);
 242 }
 243
 244 void
 245 glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count,
 246                      GLenum type, const GLvoid *indices)
 247 {
 248         TIMED_DEFER (glDrawRangeElements, mode, start, end,
 249                      count, type, indices);
 250 }
 251
 252 void
 253 glDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count,
 254                         GLenum type, const GLvoid *indices)
 255 {
 256         TIMED_DEFER (glDrawRangeElementsEXT, mode, start, end,
 257                      count, type, indices);
 258 }
 259
 260 void
 261 glDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end,
 262                                GLsizei count, GLenum type,
 263                                const GLvoid *indices, GLint basevertex)
 264 {
 265         TIMED_DEFER (glDrawRangeElementsBaseVertex, mode, start, end,
 266                      count, type, indices, basevertex);
 267 }
 268
 269 void
 270 glMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type,
 271                      const GLvoid* *indices, GLsizei primcount)
 272 {
 273         TIMED_DEFER (glMultiDrawElements, mode, count, type,
 274                      indices, primcount);
 275 }
 276
 277 void
 278 glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count,
 279                                GLenum type, const GLvoid* *indices,
 280                                GLsizei primcount, const GLint *basevertex)
 281 {
 282         TIMED_DEFER (glMultiDrawElementsBaseVertex, mode, count,
 283                      type, indices, primcount, basevertex);
 284 }
 285
 286 void
 287 glMultiDrawElementsEXT (GLenum mode, const GLsizei *count, GLenum type,
 288                         const GLvoid* *indices, GLsizei primcount)
 289 {
 290         TIMED_DEFER (glMultiDrawElementsEXT, mode, count,
 291                      type, indices, primcount);
 292 }
 293
 294 void
 295 glMultiModeDrawElementsIBM (const GLenum *mode, const GLsizei *count,
 296                             GLenum type, const GLvoid* const *indices,
 297                             GLsizei primcount, GLint modestride)
 298 {
 299         TIMED_DEFER (glMultiModeDrawElementsIBM, mode, count,
 300                      type, indices, primcount, modestride);
 301 }
 302
 303 void
 304 glMultiDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect,
 305                              GLsizei drawcount, GLsizei stride)
 306 {
 307         TIMED_DEFER (glMultiDrawElementsIndirect, mode, type,
 308                      indirect, drawcount, stride);
 309 }
 310
 311 void
 312 glMultiDrawElementsIndirectAMD (GLenum mode, GLenum type,
 313                                 const GLvoid *indirect,
 314                                 GLsizei primcount, GLsizei stride)
 315 {
 316         TIMED_DEFER (glMultiDrawElementsIndirectAMD, mode, type,
 317                      indirect, primcount, stride);
 318 }
 319
 320 void
 321 glCallList (GLuint list)
 322 {
 323         TIMED_DEFER (glCallList, list);
 324 }
 325
 326 void
 327 glCallLists (GLsizei n, GLenum type, const GLvoid *lists)
 328 {
 329         TIMED_DEFER (glCallLists, n, type, lists);
 330 }
 331
 332 void
 333 glClear (GLbitfield mask)
 334 {
 335         TIMED_DEFER (glClear, mask);
 336 }
 337
 338 /* We can't just use TIMED_DEFER for glBegin/glEnd since the
 339  * glBeginQuery/glEndQuery calls must both be outside
 340  * glBegin/glEnd. */
 341 void
 342 glBegin (GLenum mode)
 343 {
 344         if (! inside_new_list)
 345         {
 346                 unsigned counter;
 347                 counter = metrics_add_counter ();
 348                 glBeginQuery (GL_TIME_ELAPSED, counter);
 349         }
 350
 351         GLWRAP_DEFER (glBegin, mode);
 352 }
 353
 354 void
 355 glEnd (void)
 356 {
 357         GLWRAP_DEFER (glEnd);
 358
 359         if (! inside_new_list) {
 360                 glEndQuery (GL_TIME_ELAPSED);
 361         }
 362 }
 363
 364 /* And we need to track display lists to avoid inserting queries
 365  * inside the list while it's being constructed. */
 366 void
 367 glNewList (GLuint list, GLenum mode)
 368 {
 369         inside_new_list = 1;
 370         GLWRAP_DEFER (glNewList, list, mode);
 371 }
 372
 373 void
 374 glEndList (void)
 375 {
 376         GLWRAP_DEFER (glEndList);
 377         inside_new_list = 0;
 378 }
 379
 380 void
 381 glDrawPixels (GLsizei width, GLsizei height, GLenum format,
 382               GLenum type, const GLvoid *pixels)
 383 {
 384         TIMED_DEFER (glDrawPixels, width, height, format, type, pixels);
 385 }
 386
 387 void
 388 glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 389                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 390                    GLbitfield mask, GLenum filter)
 391 {
 392         TIMED_DEFER (glBlitFramebuffer,
 393                      srcX0, srcY0, srcX1, srcY1,
 394                      dstX0, dstY0, dstX1, dstY1,
 395                      mask, filter);
 396 }
 397
 398 void
 399 glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 400                       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 401                       GLbitfield mask, GLenum filter)
 402 {
 403         TIMED_DEFER (glBlitFramebufferEXT,
 404                      srcX0, srcY0, srcX1, srcY1,
 405                      dstX0, dstY0, dstX1, dstY1,
 406                      mask, filter);
 407 }
 408
 409 void
 410 glUseProgram (GLuint program)
 411 {
 412         metrics_set_current_program (program);
 413
 414         GLWRAP_DEFER(glUseProgram, program);
 415 }
 416
 417 void
 418 glUseProgramObjectARB (GLhandleARB programObj)
 419 {
 420         metrics_set_current_program (programObj);
 421
 422         GLWRAP_DEFER(glUseProgramObjectARB, programObj);
 423 }