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 #include "fips.h"
  23
  24 #include "glwrap.h"
  25
  26 #include "metrics.h"
  27
  28 /* The prototypes for some OpenGL functions changed at one point from:
  29  *
  30  *      const void* *indices
  31  * to:
  32  *      const void* const coist *indices
  33  *
  34  * This makes it difficult for us to provide an implementation of
  35  * these functions that is consistent with the locally-available gl.h
  36  * since we don't know if the extra const will be present or not.
  37  *
  38  * To workaround this problem, we simply #define away const altogether
  39  * before including gl.h.
  40  *
  41  * Kudos to Keith Packard for suggesting this kludge.
  42  */
  43 #define const
  44
  45 #define GL_GLEXT_PROTOTYPES
  46 #include <GL/gl.h>
  47
  48 #include "dlwrap.h"
  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 glBegineQuery/glEndQuery pair around an OpenGL call. */
  69 #define TIMED_DEFER(function,...) do {                  \
  70         unsigned counter;                               \
  71         counter = metrics_add_counter ();               \
  72         glBeginQuery (GL_TIME_ELAPSED, counter);        \
  73         GLWRAP_DEFER(function, __VA_ARGS__);            \
  74         glEndQuery (GL_TIME_ELAPSED);                   \
  75 } while (0);
  76
  77 /* Thanks to apitrace source code for the list of OpenGL draw calls. */
  78 void
  79 glDrawArrays (GLenum mode, GLint first, GLsizei count)
  80 {
  81         TIMED_DEFER (glDrawArrays, mode, first, count);
  82 }
  83
  84 void
  85 glDrawArraysEXT (GLenum mode, GLint first, GLsizei count)
  86 {
  87         TIMED_DEFER (glDrawArraysEXT, mode, first, count);
  88 }
  89
  90 void
  91 glDrawArraysIndirect (GLenum mode, const GLvoid *indirect)
  92 {
  93         TIMED_DEFER (glDrawArraysIndirect, mode, indirect);
  94 }
  95
  96 void
  97 glDrawArraysInstanced (GLenum mode, GLint first, GLsizei count,
  98                        GLsizei primcount)
  99 {
 100         TIMED_DEFER (glDrawArraysInstanced, mode, first, count, primcount);
 101 }
 102
 103 void
 104 glDrawArraysInstancedARB (GLenum mode, GLint first, GLsizei count,
 105                           GLsizei primcount)
 106 {
 107         TIMED_DEFER (glDrawArraysInstancedARB, mode, first, count, primcount);
 108 }
 109
 110 void
 111 glDrawArraysInstancedEXT (GLenum mode, GLint start, GLsizei count,
 112                           GLsizei primcount)
 113 {
 114         TIMED_DEFER (glDrawArraysInstancedEXT, mode, start, count, primcount);
 115 }
 116
 117 void
 118 glDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count,
 119                                    GLsizei primcount, GLuint baseinstance)
 120 {
 121         TIMED_DEFER (glDrawArraysInstancedBaseInstance, mode,
 122                      first, count, primcount, baseinstance);
 123 }
 124
 125 void
 126 glDrawMeshArraysSUN (GLenum mode, GLint first, GLsizei count, GLsizei width)
 127 {
 128         TIMED_DEFER (glDrawMeshArraysSUN, mode, first, count, width);
 129 }
 130
 131 void
 132 glMultiDrawArrays (GLenum mode, const GLint *first,
 133                    const GLsizei *count, GLsizei primcount)
 134 {
 135         TIMED_DEFER (glMultiDrawArrays, mode, first, count, primcount);
 136 }
 137
 138 void
 139 glMultiDrawArraysEXT (GLenum mode, const GLint *first,
 140                       const GLsizei *count, GLsizei primcount)
 141 {
 142         TIMED_DEFER (glMultiDrawArraysEXT, mode, first, count, primcount);
 143 }
 144
 145 void
 146 glMultiModeDrawArraysIBM (const GLenum *mode, const GLint *first,
 147                           const GLsizei *count, GLsizei primcount,
 148                           GLint modestride)
 149 {
 150         TIMED_DEFER (glMultiModeDrawArraysIBM, mode,
 151                      first, count, primcount, modestride);
 152 }
 153
 154 /* FIXME?
 155 void
 156 glMultiDrawArraysIndirect (...)
 157 {
 158         TIMED_DEFER (glMultiDrawArraysIndirect, ...);
 159 }
 160 */
 161
 162 void
 163 glMultiDrawArraysIndirectAMD (GLenum mode, const GLvoid *indirect,
 164                               GLsizei primcount, GLsizei stride)
 165 {
 166         TIMED_DEFER (glMultiDrawArraysIndirectAMD, mode,
 167                      indirect, primcount, stride);
 168 }
 169
 170 void
 171 glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 172 {
 173         TIMED_DEFER (glDrawElements, mode, count, type, indices);
 174 }
 175
 176 void
 177 glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type,
 178                           const GLvoid *indices, GLint basevertex)
 179 {
 180         TIMED_DEFER (glDrawElementsBaseVertex, mode, count,
 181                      type, indices, basevertex);
 182 }
 183
 184 void
 185 glDrawElementsIndirect (GLenum mode, GLenum type, const GLvoid *indirect)
 186 {
 187         TIMED_DEFER (glDrawElementsIndirect, mode, type, indirect);
 188 }
 189
 190 void
 191 glDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type,
 192                          const GLvoid *indices, GLsizei primcount)
 193 {
 194         TIMED_DEFER (glDrawElementsInstanced, mode, count,
 195                      type, indices, primcount);
 196 }
 197
 198 void
 199 glDrawElementsInstancedARB (GLenum mode, GLsizei count, GLenum type,
 200                             const GLvoid *indices, GLsizei primcount)
 201 {
 202         TIMED_DEFER (glDrawElementsInstancedARB, mode, count,
 203                      type, indices, primcount);
 204 }
 205
 206 void
 207 glDrawElementsInstancedEXT (GLenum mode, GLsizei count, GLenum type,
 208                             const GLvoid *indices, GLsizei primcount)
 209 {
 210         TIMED_DEFER (glDrawElementsInstancedEXT, mode, count,
 211                      type, indices, primcount);
 212 }
 213
 214 void
 215 glDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type,
 216                                    const GLvoid *indices, GLsizei primcount,
 217                                    GLint basevertex)
 218 {
 219         TIMED_DEFER (glDrawElementsInstancedBaseVertex, mode, count,
 220                      type, indices, primcount, basevertex);
 221 }
 222
 223 void
 224 glDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type,
 225                                      const void *indices, GLsizei primcount,
 226                                      GLuint baseinstance)
 227 {
 228         TIMED_DEFER (glDrawElementsInstancedBaseInstance, mode, count, type,
 229                      indices, primcount, baseinstance);
 230 }
 231
 232 void
 233 glDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count,
 234                       GLenum type, const void *indices, GLsizei primcount,
 235                       GLint basevertex, GLuint baseinstance)
 236 {
 237         TIMED_DEFER (glDrawElementsInstancedBaseVertexBaseInstance, mode,
 238                      count, type, indices, primcount, basevertex, baseinstance);
 239 }
 240
 241 void
 242 glDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count,
 243                      GLenum type, const GLvoid *indices)
 244 {
 245         TIMED_DEFER (glDrawRangeElements, mode, start, end,
 246                      count, type, indices);
 247 }
 248
 249 void
 250 glDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count,
 251                         GLenum type, const GLvoid *indices)
 252 {
 253         TIMED_DEFER (glDrawRangeElementsEXT, mode, start, end,
 254                      count, type, indices);
 255 }
 256
 257 void
 258 glDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end,
 259                                GLsizei count, GLenum type,
 260                                const GLvoid *indices, GLint basevertex)
 261 {
 262         TIMED_DEFER (glDrawRangeElementsBaseVertex, mode, start, end,
 263                      count, type, indices, basevertex);
 264 }
 265
 266 void
 267 glMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type,
 268                      const GLvoid* *indices, GLsizei primcount)
 269 {
 270         TIMED_DEFER (glMultiDrawElements, mode, count, type,
 271                      indices, primcount);
 272 }
 273
 274 void
 275 glMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count,
 276                                GLenum type, const GLvoid* *indices,
 277                                GLsizei primcount, const GLint *basevertex)
 278 {
 279         TIMED_DEFER (glMultiDrawElementsBaseVertex, mode, count,
 280                      type, indices, primcount, basevertex);
 281 }
 282
 283 void
 284 glMultiDrawElementsEXT (GLenum mode, const GLsizei *count, GLenum type,
 285                         const GLvoid* *indices, GLsizei primcount)
 286 {
 287         TIMED_DEFER (glMultiDrawElementsEXT, mode, count,
 288                      type, indices, primcount);
 289 }
 290
 291 void
 292 glMultiModeDrawElementsIBM (const GLenum *mode, const GLsizei *count,
 293                             GLenum type, const GLvoid* const *indices,
 294                             GLsizei primcount, GLint modestride)
 295 {
 296         TIMED_DEFER (glMultiModeDrawElementsIBM, mode, count,
 297                      type, indices, primcount, modestride);
 298 }
 299
 300 /* FIXME?
 301 void
 302 glMultiDrawElementsIndirect (...)
 303 {
 304         TIMED_DEFER (glMultiDrawElementsIndirect, ...);
 305 }
 306 */
 307
 308 void
 309 glMultiDrawElementsIndirectAMD (GLenum mode, GLenum type,
 310                                 const GLvoid *indirect,
 311                                 GLsizei primcount, GLsizei stride)
 312 {
 313         TIMED_DEFER (glMultiDrawElementsIndirectAMD, mode, type,
 314                      indirect, primcount, stride);
 315 }
 316
 317 void
 318 glCallList (GLuint list)
 319 {
 320         TIMED_DEFER (glCallList, list);
 321 }
 322
 323 void
 324 glCallLists (GLsizei n, GLenum type, const GLvoid *lists)
 325 {
 326         TIMED_DEFER (glCallLists, n, type, lists);
 327 }
 328
 329 void
 330 glClear (GLbitfield mask)
 331 {
 332         TIMED_DEFER (glClear, mask);
 333 }
 334
 335 void
 336 glEnd (void)
 337 {
 338         TIMED_DEFER (glEnd,);
 339 }
 340
 341 void
 342 glDrawPixels (GLsizei width, GLsizei height, GLenum format,
 343               GLenum type, const GLvoid *pixels)
 344 {
 345         TIMED_DEFER (glDrawPixels, width, height, format, type, pixels);
 346 }
 347
 348 void
 349 glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 350                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 351                    GLbitfield mask, GLenum filter)
 352 {
 353         TIMED_DEFER (glBlitFramebuffer,
 354                      srcX0, srcY0, srcX1, srcY1,
 355                      dstX0, dstY0, dstX1, dstY1,
 356                      mask, filter);
 357 }
 358
 359 void
 360 glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 361                       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 362                       GLbitfield mask, GLenum filter)
 363 {
 364         TIMED_DEFER (glBlitFramebufferEXT,
 365                      srcX0, srcY0, srcX1, srcY1,
 366                      dstX0, dstY0, dstX1, dstY1,
 367                      mask, filter);
 368 }
 369
 370 void
 371 glUseProgram (GLuint program)
 372 {
 373         metrics_set_current_program (program);
 374
 375         GLWRAP_DEFER(glUseProgram, program);
 376 }
 377
 378 void
 379 glUseProgramObjectARB (GLhandleARB programObj)
 380 {
 381         metrics_set_current_program (programObj);
 382
 383         GLWRAP_DEFER(glUseProgramObjectARB, programObj);
 384 }