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 "dlwrap.h"
  23
  24 /* The prototypes for some OpenGL functions changed at one point from:
  25  *
  26  *      const void* *indices
  27  * to:
  28  *      const void* const coist *indices
  29  *
  30  * This makes it difficult for us to provide an implementation of
  31  * these functions that is consistent with the locally-available gl.h
  32  * since we don't know if the extra const will be present or not.
  33  *
  34  * To workaround this problem, we simply #define away const altogether
  35  * before including gl.h.
  36  *
  37  * Kudos to Keith Packard for suggesting this kludge.
  38  */
  39 #define const
  40
  41 #define GL_GLEXT_PROTOTYPES
  42 #include <GL/gl.h>
  43
  44 #include "fips.h"
  45
  46 #include "glwrap.h"
  47
  48 #include "metrics.h"
  49
  50 static void *gl_handle;
  51
  52 /* Switch metrics operation persistently, (until next SWITCH) */
  53 #define SWITCH_METRICS_OP(op)                   \
  54         metrics_counter_stop ();                \
  55         metrics_set_current_op (op);            \
  56         metrics_counter_start ();
  57
  58 /* Switch metrics operation temporarily, see RESTORE_METRICS_OP */
  59 #define SAVE_THEN_SWITCH_METRICS_OP(op)                 \
  60         metrics_op_t save = metrics_get_current_op ();  \
  61         SWITCH_METRICS_OP (op);
  62
  63 /* Switch back to metrics operation saved by SAVE_THEN_SWITCH_METRICS_OP */
  64 #define RESTORE_METRICS_OP(op)                          \
  65         SWITCH_METRICS_OP (save);
  66
  67 void
  68 glwrap_set_gl_handle (void *handle)
  69 {
  70         if (gl_handle == NULL)
  71                 gl_handle = handle;
  72 }
  73
  74 void *
  75 glwrap_lookup (char *name)
  76 {
  77         void *ret;
  78
  79         /* We don't call dlopen here to find the library in which to
  80          * perform a dlsym lookup. That's because the application may
  81          * be loading libGL.so or libGLESv2.so for its OpenGL symbols.
  82          *
  83          * So we instead watch for one of those filenames to go by in
  84          * our dlopen wrapper, which will then call
  85          * glwrap_set_gl_handle to give us the handle to use here.
  86          *
  87          * If the application hasn't called dlopen on a "libGL"
  88          * library, then presumably the application is linked directly
  89          * to an OpenGL implementation. In this case, we can use
  90          * RTLD_NEXT to find the symbol.
  91          *
  92          * But just in case, we also let the user override that by
  93          * specifying the FIPS_LIBGL environment variable to the path
  94          * of the real libGL.so library that fips should dlopen here.
  95          */
  96         if (gl_handle == NULL) {
  97                 const char *path;
  98
  99                 path = getenv ("FIPS_LIBGL");
 100                 if (! path)
 101                         path = getenv ("GLAZE_LIBGL");
 102                 if (path) {
 103                         gl_handle = dlopen (path, RTLD_LAZY);
 104
 105                         if (gl_handle == NULL) {
 106                                 fprintf (stderr, "Failed to dlopen FIPS_LIBGL: "
 107                                          "%s\n", path);
 108                                 exit (1);
 109                         }
 110                 } else {
 111                         gl_handle = RTLD_NEXT;
 112                 }
 113         }
 114
 115         ret = dlwrap_real_dlsym (gl_handle, name);
 116
 117         if (ret == NULL) {
 118                 fprintf (stderr, "fips: Error: glwrap_lookup failed to dlsym %s\n",
 119                          name);
 120                 exit (1);
 121         }
 122
 123         return ret;
 124 }
 125
 126 /* With a program change, we stop the counter, update the
 127  * active program, then start the counter up again. */
 128 void
 129 glUseProgram (GLuint program)
 130 {
 131         SWITCH_METRICS_OP (METRICS_OP_SHADER + program);
 132
 133         GLWRAP_DEFER(glUseProgram, program);
 134 }
 135
 136 void
 137 glUseProgramObjectARB (GLhandleARB programObj)
 138 {
 139         SWITCH_METRICS_OP (METRICS_OP_SHADER + programObj);
 140
 141         GLWRAP_DEFER(glUseProgramObjectARB, programObj);
 142 }
 143
 144 /* METRICS_OP_ACCUM */
 145 void
 146 glAccum (GLenum op, GLfloat value)
 147 {
 148         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_ACCUM);
 149
 150         GLWRAP_DEFER (glAccum, op, value);
 151
 152         RESTORE_METRICS_OP ();
 153 }
 154
 155 void
 156 glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 157 {
 158         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_ACCUM);
 159
 160         GLWRAP_DEFER (glClearAccum, red, green, blue, alpha);
 161
 162         RESTORE_METRICS_OP ();
 163 }
 164
 165 void
 166 glClearAccumxOES (GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 167 {
 168         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_ACCUM);
 169
 170         GLWRAP_DEFER (glClearAccumxOES, red, green, blue, alpha);
 171
 172         RESTORE_METRICS_OP ();
 173 }
 174
 175 /* METRICS_OP_BUFFER_DATA */
 176 void
 177 glBufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 178 {
 179         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 180
 181         GLWRAP_DEFER (glBufferData, target, size, data, usage);
 182
 183         RESTORE_METRICS_OP ();
 184 }
 185
 186 void
 187 glNamedBufferDataEXT (GLuint buffer, GLsizeiptr size, const GLvoid *data,
 188                       GLenum usage)
 189 {
 190         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 191
 192         GLWRAP_DEFER (glNamedBufferDataEXT, buffer, size, data, usage);
 193
 194         RESTORE_METRICS_OP ();
 195 }
 196
 197 void
 198 glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size,
 199                  const GLvoid *data)
 200 {
 201         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 202
 203         GLWRAP_DEFER (glBufferSubData, target, offset, size, data);
 204
 205         RESTORE_METRICS_OP ();
 206 }
 207
 208 void
 209 glNamedBufferSubDataEXT (GLuint buffer, GLintptr offset, GLsizeiptr size,
 210                          const GLvoid *data)
 211 {
 212         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 213
 214         GLWRAP_DEFER (glNamedBufferSubDataEXT, buffer, offset, size, data);
 215
 216         RESTORE_METRICS_OP ();
 217 }
 218
 219 void *
 220 glMapBuffer (GLenum target, GLenum access)
 221 {
 222         void *ret;
 223
 224         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 225
 226         GLWRAP_DEFER_WITH_RETURN (ret, glMapBuffer, target, access);
 227
 228         RESTORE_METRICS_OP ();
 229
 230         return ret;
 231 }
 232
 233 void *
 234 glMapBufferARB (GLenum target, GLenum access)
 235 {
 236         void *ret;
 237
 238         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 239
 240         GLWRAP_DEFER_WITH_RETURN (ret, glMapBufferARB, target, access);
 241
 242         RESTORE_METRICS_OP ();
 243
 244         return ret;
 245 }
 246
 247 void *
 248 glMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length,
 249                   GLbitfield access)
 250 {
 251         void *ret;
 252
 253         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 254
 255         GLWRAP_DEFER_WITH_RETURN (ret, glMapBufferRange, target, offset,
 256                                   length, access);
 257
 258         RESTORE_METRICS_OP ();
 259
 260         return ret;
 261 }
 262
 263 GLboolean
 264 glUnmapBuffer (GLenum target)
 265 {
 266         GLboolean ret;
 267
 268         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 269
 270         GLWRAP_DEFER_WITH_RETURN (ret, glUnmapBuffer, target);
 271
 272         RESTORE_METRICS_OP ();
 273
 274         return ret;
 275 }
 276
 277 GLboolean
 278 glUnmapNamedBufferEXT (GLuint buffer)
 279 {
 280         GLboolean ret;
 281
 282         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 283
 284         GLWRAP_DEFER_WITH_RETURN (ret, glUnmapNamedBufferEXT, buffer);
 285
 286         RESTORE_METRICS_OP ();
 287
 288         return ret;
 289 }
 290
 291 GLboolean
 292 glUnmapBufferARB (GLenum target)
 293 {
 294         GLboolean ret;
 295
 296         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 297
 298         GLWRAP_DEFER_WITH_RETURN (ret, glUnmapBufferARB, target);
 299
 300         RESTORE_METRICS_OP ();
 301
 302         return ret;
 303 }
 304
 305 void
 306 glFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length)
 307 {
 308         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 309
 310         GLWRAP_DEFER (glFlushMappedBufferRange, target, offset, length);
 311
 312         RESTORE_METRICS_OP ();
 313 }
 314
 315 void
 316 glFlushMappedBufferRangeAPPLE (GLenum target, GLintptr offset, GLsizeiptr size)
 317 {
 318         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 319
 320         GLWRAP_DEFER (glFlushMappedBufferRangeAPPLE, target, offset, size);
 321
 322         RESTORE_METRICS_OP ();
 323 }
 324
 325 void
 326 glFlushMappedNamedBufferRangeEXT (GLuint buffer, GLintptr offset,
 327                                   GLsizeiptr length)
 328 {
 329         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 330
 331         GLWRAP_DEFER (glFlushMappedNamedBufferRangeEXT, buffer, offset, length);
 332
 333         RESTORE_METRICS_OP ();
 334 }
 335
 336 void *
 337 glMapNamedBufferEXT (GLuint buffer, GLenum access)
 338 {
 339         void *ret;
 340
 341         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 342
 343         GLWRAP_DEFER_WITH_RETURN (ret, glMapNamedBufferEXT, buffer, access);
 344
 345         RESTORE_METRICS_OP ();
 346
 347         return ret;
 348 }
 349
 350 void *
 351 glMapNamedBufferRangeEXT (GLuint buffer, GLintptr offset, GLsizeiptr length,
 352                           GLbitfield access)
 353 {
 354         void *ret;
 355
 356         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_DATA);
 357
 358         GLWRAP_DEFER_WITH_RETURN (ret, glMapNamedBufferRangeEXT, buffer,
 359                                   offset, length, access);
 360
 361         RESTORE_METRICS_OP ();
 362
 363         return ret;
 364 }
 365
 366 /* METRICS_OP_BUFFER_SUB_DATA */
 367 void
 368 glCopyBufferSubData (GLenum readTarget, GLenum writeTarget,
 369                      GLintptr readOffset, GLintptr writeOffset,
 370                      GLsizeiptr size)
 371 {
 372         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_SUB_DATA);
 373
 374         GLWRAP_DEFER (glCopyBufferSubData, readTarget, writeTarget,
 375                       readOffset, writeOffset, size);
 376
 377         RESTORE_METRICS_OP ();
 378 }
 379
 380 void
 381 glNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer,
 382                              GLintptr readOffset, GLintptr writeOffset,
 383                              GLsizeiptr size)
 384 {
 385         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BUFFER_SUB_DATA);
 386
 387         GLWRAP_DEFER (glNamedCopyBufferSubDataEXT, readBuffer,
 388                       writeBuffer, readOffset, writeOffset, size);
 389
 390         RESTORE_METRICS_OP ();
 391 }
 392
 393 /* METRICS_OP_BITMAP */
 394 void
 395 glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
 396           GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 397 {
 398         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BITMAP);
 399
 400         GLWRAP_DEFER (glBitmap, width, height, xorig, yorig,
 401                       xmove, ymove, bitmap);
 402
 403         RESTORE_METRICS_OP ();
 404 }
 405
 406 void
 407 glBitmapxOES (GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig,
 408               GLfixed xmove, GLfixed ymove, const GLubyte *bitmap)
 409 {
 410         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BITMAP);
 411
 412         GLWRAP_DEFER (glBitmapxOES, width, height, xorig, yorig,
 413                       xmove, ymove, bitmap);
 414
 415         RESTORE_METRICS_OP ();
 416 }
 417
 418 /* METRICS_OP_BLIT_FRAMEBUFFER */
 419 void
 420 glBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 421                    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 422                    GLbitfield mask, GLenum filter)
 423 {
 424         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BLIT_FRAMEBUFFER);
 425
 426         GLWRAP_DEFER (glBlitFramebuffer, srcX0, srcY0, srcX1, srcY1,
 427                       dstX0, dstY0, dstX1, dstY1, mask, filter);
 428
 429         RESTORE_METRICS_OP ();
 430 }
 431
 432 void
 433 glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
 434                       GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
 435                       GLbitfield mask, GLenum filter)
 436 {
 437         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_BLIT_FRAMEBUFFER);
 438
 439         GLWRAP_DEFER (glBlitFramebufferEXT, srcX0, srcY0, srcX1, srcY1,
 440                       dstX0, dstY0, dstX1, dstY1, mask, filter);
 441
 442         RESTORE_METRICS_OP ();
 443 }
 444
 445 /* METRICS_OP_CLEAR */
 446 void
 447 glClear (GLbitfield mask)
 448 {
 449         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 450
 451         GLWRAP_DEFER (glClear, mask);
 452
 453         RESTORE_METRICS_OP ();
 454 }
 455
 456 void
 457 glClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 458 {
 459         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 460
 461         GLWRAP_DEFER (glClearBufferfi, buffer, drawbuffer, depth, stencil);
 462
 463         RESTORE_METRICS_OP ();
 464 }
 465
 466 void
 467 glClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value)
 468 {
 469         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 470
 471         GLWRAP_DEFER (glClearBufferfv, buffer, drawbuffer, value);
 472
 473         RESTORE_METRICS_OP ();
 474 }
 475
 476 void
 477 glClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value)
 478 {
 479         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 480
 481         GLWRAP_DEFER (glClearBufferiv, buffer, drawbuffer, value);
 482
 483         RESTORE_METRICS_OP ();
 484 }
 485
 486 void
 487 glClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value)
 488 {
 489         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR);
 490
 491         GLWRAP_DEFER (glClearBufferuiv, buffer, drawbuffer, value);
 492
 493         RESTORE_METRICS_OP ();
 494 }
 495
 496 /* METRICS_OP_CLEAR_BUFFER_DATA */
 497
 498 void
 499 glClearBufferData (GLenum target, GLenum internalformat, GLenum format,
 500                    GLenum type, const void *data)
 501 {
 502         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 503
 504         GLWRAP_DEFER (glClearBufferData, target, internalformat, format,
 505                       type, data);
 506
 507         RESTORE_METRICS_OP ();
 508 }
 509
 510 void
 511 glClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset,
 512                       GLsizeiptr size, GLenum format, GLenum type,
 513                       const void *data)
 514 {
 515         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 516
 517         GLWRAP_DEFER (glClearBufferSubData, target, internalformat,
 518                       offset, size, format, type, data);
 519
 520         RESTORE_METRICS_OP ();
 521 }
 522
 523 void
 524 glClearNamedBufferDataEXT (GLuint buffer, GLenum internalformat, GLenum format,
 525                            GLenum type, const void *data)
 526 {
 527         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 528
 529         GLWRAP_DEFER (glClearNamedBufferDataEXT, buffer, internalformat,
 530                       format, type, data);
 531
 532         RESTORE_METRICS_OP ();
 533 }
 534
 535 void
 536 glClearNamedBufferSubDataEXT (GLuint buffer, GLenum internalformat,
 537                               GLenum format, GLenum type, GLsizeiptr offset,
 538                               GLsizeiptr size, const void *data)
 539 {
 540         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_CLEAR_BUFFER_DATA);
 541
 542         GLWRAP_DEFER (glClearNamedBufferSubDataEXT, buffer,
 543                       internalformat, format, type, offset, size, data);
 544
 545         RESTORE_METRICS_OP ();
 546 }
 547
 548 /* METRICS_OP_CLEAR_TEX_IMAGE */
 549
 550
 551 /* METRICS_OP_COPY_PIXELS */
 552 void
 553 glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
 554 {
 555         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_PIXELS);
 556
 557         GLWRAP_DEFER (glCopyPixels, x, y, width, height, type);
 558
 559         RESTORE_METRICS_OP ();
 560 }
 561
 562 /* METRICS_OP_COPY_TEX_IMAGE */
 563 void
 564 glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat,
 565                   GLint x, GLint y, GLsizei width, GLint border)
 566 {
 567         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 568
 569         GLWRAP_DEFER (glCopyTexImage1D, target, level, internalformat,
 570                       x, y, width, border);
 571
 572         RESTORE_METRICS_OP ();
 573 }
 574
 575 void
 576 glCopyTexImage1DEXT (GLenum target, GLint level, GLenum internalformat,
 577                      GLint x, GLint y, GLsizei width, GLint border)
 578 {
 579         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 580
 581         GLWRAP_DEFER (glCopyTexImage1DEXT, target, level, internalformat,
 582                       x, y, width, border);
 583
 584         RESTORE_METRICS_OP ();
 585 }
 586
 587 void
 588 glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat,
 589                   GLint x, GLint y, GLsizei width, GLsizei height,
 590                   GLint border)
 591 {
 592         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 593
 594         GLWRAP_DEFER (glCopyTexImage2D, target, level, internalformat,
 595                       x, y, width, height, border);
 596
 597         RESTORE_METRICS_OP ();
 598 }
 599
 600 void
 601 glCopyTexImage2DEXT (GLenum target, GLint level, GLenum internalformat,
 602                      GLint x, GLint y, GLsizei width, GLsizei height,
 603                      GLint border)
 604 {
 605         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 606
 607         GLWRAP_DEFER (glCopyTexImage2DEXT, target, level, internalformat,
 608                       x, y, width, height, border);
 609
 610         RESTORE_METRICS_OP ();
 611 }
 612
 613 void
 614 glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset,
 615                      GLint x, GLint y, GLsizei width)
 616 {
 617         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 618
 619         GLWRAP_DEFER (glCopyTexSubImage1D, target, level, xoffset,
 620                       x, y, width);
 621
 622         RESTORE_METRICS_OP ();
 623 }
 624
 625 void
 626 glCopyTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset,
 627                         GLint x, GLint y, GLsizei width)
 628 {
 629         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 630
 631         GLWRAP_DEFER (glCopyTexSubImage1DEXT, target, level, xoffset,
 632                       x, y, width);
 633
 634         RESTORE_METRICS_OP ();
 635 }
 636
 637 void
 638 glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset,
 639                      GLint yoffset, GLint x, GLint y, GLsizei width,
 640                      GLsizei height)
 641 {
 642         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 643
 644         GLWRAP_DEFER (glCopyTexSubImage2D, target, level, xoffset, yoffset,
 645                       x, y, width, height);
 646
 647         RESTORE_METRICS_OP ();
 648 }
 649
 650 void
 651 glCopyTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset,
 652                         GLint yoffset, GLint x, GLint y, GLsizei width,
 653                         GLsizei height)
 654 {
 655         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 656
 657         GLWRAP_DEFER (glCopyTexSubImage2DEXT, target, level, xoffset, yoffset,
 658                       x, y, width, height);
 659
 660         RESTORE_METRICS_OP ();
 661 }
 662
 663 void
 664 glCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset,
 665                      GLint yoffset, GLint zoffset, GLint x, GLint y,
 666                      GLsizei width, GLsizei height)
 667 {
 668         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 669
 670         GLWRAP_DEFER (glCopyTexSubImage3D, target, level, xoffset, yoffset,
 671                       zoffset, x, y, width, height);
 672
 673         RESTORE_METRICS_OP ();
 674 }
 675
 676 void
 677 glCopyTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset,
 678                         GLint yoffset, GLint zoffset, GLint x, GLint y,
 679                         GLsizei width, GLsizei height)
 680 {
 681         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 682
 683         GLWRAP_DEFER (glCopyTexSubImage3DEXT, target, level, xoffset, yoffset,
 684                       zoffset, x, y, width, height);
 685
 686         RESTORE_METRICS_OP ();
 687 }
 688
 689 void
 690 glCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level,
 691                          GLenum internalformat, GLint x, GLint y,
 692                          GLsizei width, GLint border)
 693 {
 694         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 695
 696         GLWRAP_DEFER (glCopyTextureImage1DEXT, texture, target, level,
 697                       internalformat, x, y, width, border);
 698
 699         RESTORE_METRICS_OP ();
 700 }
 701
 702 void
 703 glCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level,
 704                          GLenum internalformat, GLint x, GLint y, GLsizei width,
 705                          GLsizei height, GLint border)
 706 {
 707         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 708
 709         GLWRAP_DEFER (glCopyTextureImage2DEXT, texture, target,
 710                       level, internalformat, x, y, width, height, border);
 711
 712         RESTORE_METRICS_OP ();
 713 }
 714
 715 void
 716 glCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level,
 717                             GLint xoffset, GLint x, GLint y, GLsizei width)
 718 {
 719         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 720
 721         GLWRAP_DEFER (glCopyTextureSubImage1DEXT, texture, target, level,
 722                       xoffset, x, y, width);
 723
 724         RESTORE_METRICS_OP ();
 725 }
 726
 727 void
 728 glCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level,
 729                             GLint xoffset, GLint yoffset, GLint x, GLint y,
 730                             GLsizei width, GLsizei height)
 731 {
 732         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 733
 734         GLWRAP_DEFER (glCopyTextureSubImage2DEXT, texture, target, level,
 735                       xoffset, yoffset, x, y, width, height);
 736
 737         RESTORE_METRICS_OP ();
 738 }
 739
 740 void
 741 glCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level,
 742                             GLint xoffset, GLint yoffset, GLint zoffset,
 743                             GLint x, GLint y, GLsizei width, GLsizei height)
 744 {
 745         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 746
 747         GLWRAP_DEFER (glCopyTextureSubImage3DEXT, texture, target, level,
 748                       xoffset, yoffset, zoffset, x, y, width, height);
 749
 750         RESTORE_METRICS_OP ();
 751 }
 752
 753 void
 754 glCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
 755                           GLenum internalformat, GLint x, GLint y,
 756                           GLsizei width, GLint border)
 757 {
 758         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 759
 760         GLWRAP_DEFER (glCopyMultiTexImage1DEXT, texunit, target, level,
 761                       internalformat, x, y, width, border);
 762
 763         RESTORE_METRICS_OP ();
 764 }
 765
 766 void
 767 glCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
 768                           GLenum internalformat, GLint x, GLint y,
 769                           GLsizei width, GLsizei height, GLint border)
 770 {
 771         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 772
 773         GLWRAP_DEFER (glCopyMultiTexImage2DEXT, texunit, target, level,
 774                       internalformat, x, y, width, height, border);
 775
 776         RESTORE_METRICS_OP ();
 777 }
 778
 779 void
 780 glCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
 781                              GLint xoffset, GLint x, GLint y, GLsizei width)
 782 {
 783         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 784
 785         GLWRAP_DEFER (glCopyMultiTexSubImage1DEXT, texunit, target, level,
 786                       xoffset, x, y, width);
 787
 788         RESTORE_METRICS_OP ();
 789 }
 790
 791 void
 792 glCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
 793                              GLint xoffset, GLint yoffset, GLint x, GLint y,
 794                              GLsizei width, GLsizei height)
 795 {
 796         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 797
 798         GLWRAP_DEFER (glCopyMultiTexSubImage2DEXT, texunit, target, level,
 799                       xoffset, yoffset, x, y, width, height);
 800
 801         RESTORE_METRICS_OP ();
 802 }
 803
 804 void
 805 glCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
 806                              GLint xoffset, GLint yoffset, GLint zoffset,
 807                              GLint x, GLint y, GLsizei width, GLsizei height)
 808 {
 809         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_COPY_TEX_IMAGE);
 810
 811         GLWRAP_DEFER (glCopyMultiTexSubImage3DEXT, texunit, target, level,
 812                       xoffset, yoffset, zoffset, x, y, width, height);
 813
 814         RESTORE_METRICS_OP ();
 815 }
 816
 817 /* METRICS_OP_DRAW_PIXELS */
 818 void
 819 glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type,
 820               const GLvoid *pixels)
 821 {
 822         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_DRAW_PIXELS);
 823
 824         GLWRAP_DEFER (glDrawPixels, width, height, format, type, pixels);
 825
 826         RESTORE_METRICS_OP ();
 827 }
 828
 829 /* METRICS_OP_GET_TEX_IMAGE */
 830
 831 void
 832 glGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target,
 833                                  GLint lod, GLvoid *img)
 834 {
 835         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 836
 837         GLWRAP_DEFER (glGetCompressedMultiTexImageEXT, texunit,
 838                       target, lod, img);
 839
 840         RESTORE_METRICS_OP ();
 841 }
 842
 843 void
 844 glGetCompressedTexImage (GLenum target, GLint level, GLvoid *img)
 845 {
 846         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 847
 848         GLWRAP_DEFER (glGetCompressedTexImage, target, level, img);
 849
 850         RESTORE_METRICS_OP ();
 851 }
 852
 853 void
 854 glGetCompressedTexImageARB (GLenum target, GLint level, GLvoid *img)
 855 {
 856         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 857
 858         GLWRAP_DEFER (glGetCompressedTexImageARB, target, level, img);
 859
 860         RESTORE_METRICS_OP ();
 861 }
 862
 863 void
 864 glGetCompressedTextureImageEXT (GLuint texture, GLenum target,
 865                                 GLint lod, GLvoid *img)
 866 {
 867         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 868
 869         GLWRAP_DEFER (glGetCompressedTextureImageEXT, texture,
 870                       target, lod, img);
 871
 872         RESTORE_METRICS_OP ();
 873 }
 874
 875 void
 876 glGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level,
 877                        GLenum format, GLenum type, GLvoid *pixels)
 878 {
 879         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 880
 881         GLWRAP_DEFER (glGetMultiTexImageEXT, texunit,
 882                       target, level, format, type, pixels);
 883
 884         RESTORE_METRICS_OP ();
 885 }
 886
 887 void
 888 glGetnCompressedTexImageARB (GLenum target, GLint lod,
 889                              GLsizei bufSize, GLvoid *img)
 890 {
 891         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 892
 893         GLWRAP_DEFER (glGetnCompressedTexImageARB, target, lod, bufSize, img);
 894
 895         RESTORE_METRICS_OP ();
 896 }
 897
 898 void
 899 glGetnTexImageARB (GLenum target, GLint level, GLenum format,
 900                    GLenum type, GLsizei bufSize, GLvoid *img)
 901 {
 902         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 903
 904         GLWRAP_DEFER (glGetnTexImageARB, target, level,
 905                       format, type, bufSize, img);
 906
 907         RESTORE_METRICS_OP ();
 908 }
 909
 910 void
 911 glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type,
 912                GLvoid *pixels )
 913 {
 914         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_GET_TEX_IMAGE);
 915
 916         GLWRAP_DEFER (glGetTexImage, target, level, format, type, pixels);
 917
 918         RESTORE_METRICS_OP ();
 919 }
 920
 921 /* METRICS_OP_READ_PIXELS */
 922 void
 923 glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height,
 924               GLenum format, GLenum type, GLvoid *pixels )
 925 {
 926         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS);
 927
 928         GLWRAP_DEFER (glReadPixels, x, y, width, height, format, type, pixels);
 929
 930         RESTORE_METRICS_OP ();
 931 }
 932
 933 void
 934 glReadnPixelsARB (GLint x, GLint y, GLsizei width, GLsizei height,
 935                   GLenum format, GLenum type, GLsizei bufSize, GLvoid *data)
 936 {
 937         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_READ_PIXELS);
 938
 939         GLWRAP_DEFER (glReadnPixelsARB, x, y, width, height,
 940                       format, type, bufSize, data);
 941
 942         RESTORE_METRICS_OP ();
 943 }
 944
 945 /* METRICS_OP_TEX_IMAGE */
 946 void
 947 glTexImage1D (GLenum target, GLint level, GLint internalFormat,
 948               GLsizei width, GLint border, GLenum format, GLenum type,
 949               const GLvoid *pixels)
 950 {
 951         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 952
 953         GLWRAP_DEFER (glTexImage1D, target, level, internalFormat, width,
 954                       border, format, type, pixels);
 955
 956         RESTORE_METRICS_OP ();
 957 }
 958
 959 void
 960 glTexImage2D (GLenum target, GLint level, GLint internalFormat,
 961               GLsizei width, GLsizei height, GLint border, GLenum format,
 962               GLenum type, const GLvoid *pixels )
 963 {
 964         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 965
 966         GLWRAP_DEFER (glTexImage2D, target, level, internalFormat,
 967                       width, height, border, format, type, pixels);
 968
 969         RESTORE_METRICS_OP ();
 970 }
 971
 972
 973 void
 974 glTexImage2DMultisample (GLenum target, GLsizei samples,
 975                          GLint internalformat, GLsizei width, GLsizei height,
 976                          GLboolean fixedsamplelocations)
 977 {
 978         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 979
 980         GLWRAP_DEFER (glTexImage2DMultisample, target, samples,
 981                       internalformat, width, height, fixedsamplelocations);
 982
 983         RESTORE_METRICS_OP ();
 984 }
 985
 986 void
 987 glTexImage2DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples,
 988                                    GLsizei colorSamples, GLint internalFormat,
 989                                    GLsizei width, GLsizei height,
 990                                    GLboolean fixedSampleLocations)
 991 {
 992         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
 993
 994         GLWRAP_DEFER (glTexImage2DMultisampleCoverageNV, target,
 995                       coverageSamples, colorSamples, internalFormat,
 996                       width, height, fixedSampleLocations);
 997
 998         RESTORE_METRICS_OP ();
 999 }
1000
1001 void
1002 glTexImage3D (GLenum target, GLint level, GLint internalformat,
1003               GLsizei width, GLsizei height, GLsizei depth, GLint border,
1004               GLenum format, GLenum type, const GLvoid *pixels)
1005 {
1006         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1007
1008         GLWRAP_DEFER (glTexImage3D, target, level, internalformat,
1009                       width, height, depth, border, format, type, pixels);
1010
1011         RESTORE_METRICS_OP ();
1012 }
1013
1014 void
1015 glTexImage3DEXT (GLenum target, GLint level, GLenum internalformat,
1016                  GLsizei width, GLsizei height, GLsizei depth, GLint border,
1017                  GLenum format, GLenum type, const GLvoid *pixels)
1018 {
1019         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1020
1021         GLWRAP_DEFER (glTexImage3DEXT, target, level, internalformat,
1022                       width, height, depth, border, format, type, pixels);
1023
1024         RESTORE_METRICS_OP ();
1025 }
1026
1027 void
1028 glTexImage3DMultisample (GLenum target, GLsizei samples, GLint internalformat,
1029                          GLsizei width, GLsizei height, GLsizei depth,
1030                          GLboolean fixedsamplelocations)
1031 {
1032         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1033
1034         GLWRAP_DEFER (glTexImage3DMultisample, target, samples,
1035                       internalformat, width, height, depth,
1036                       fixedsamplelocations);
1037
1038         RESTORE_METRICS_OP ();
1039 }
1040
1041 void
1042 glTexImage3DMultisampleCoverageNV (GLenum target, GLsizei coverageSamples,
1043                                    GLsizei colorSamples, GLint internalFormat,
1044                                    GLsizei width, GLsizei height, GLsizei depth,
1045                                    GLboolean fixedSampleLocations)
1046 {
1047         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1048
1049         GLWRAP_DEFER (glTexImage3DMultisampleCoverageNV, target,
1050                       coverageSamples, colorSamples, internalFormat,
1051                       width, height, depth, fixedSampleLocations);
1052
1053         RESTORE_METRICS_OP ();
1054 }
1055
1056 void
1057 glTexImage4DSGIS (GLenum target, GLint level, GLenum internalformat,
1058                   GLsizei width, GLsizei height, GLsizei depth,
1059                   GLsizei size4d, GLint border, GLenum format,
1060                   GLenum type, const GLvoid *pixels)
1061 {
1062         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1063
1064         GLWRAP_DEFER (glTexImage4DSGIS, target, level,
1065                       internalformat, width, height, depth,
1066                       size4d, border, format, type, pixels);
1067
1068         RESTORE_METRICS_OP ();
1069 }
1070
1071 void
1072 glTexSubImage1D (GLenum target, GLint level, GLint xoffset,
1073                  GLsizei width, GLenum format, GLenum type,
1074                  const GLvoid *pixels)
1075 {
1076         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1077
1078         GLWRAP_DEFER (glTexSubImage1D, target, level, xoffset,
1079                       width, format, type, pixels);
1080
1081         RESTORE_METRICS_OP ();
1082 }
1083
1084 void
1085 glTexSubImage1DEXT (GLenum target, GLint level, GLint xoffset,
1086                     GLsizei width, GLenum format, GLenum type,
1087                     const GLvoid *pixels)
1088 {
1089         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1090
1091         GLWRAP_DEFER (glTexSubImage1DEXT, target, level, xoffset,
1092                       width, format, type, pixels);
1093
1094         RESTORE_METRICS_OP ();
1095 }
1096
1097 void
1098 glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1099                  GLsizei width, GLsizei height, GLenum format, GLenum type,
1100                  const GLvoid *pixels)
1101 {
1102         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1103
1104         GLWRAP_DEFER (glTexSubImage2D, target, level, xoffset, yoffset,
1105                       width, height, format, type, pixels);
1106
1107         RESTORE_METRICS_OP ();
1108 }
1109
1110 void
1111 glTexSubImage2DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1112                     GLsizei width, GLsizei height, GLenum format, GLenum type,
1113                     const GLvoid *pixels)
1114 {
1115         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1116
1117         GLWRAP_DEFER (glTexSubImage2DEXT, target, level, xoffset, yoffset,
1118                       width, height, format, type, pixels);
1119
1120         RESTORE_METRICS_OP ();
1121 }
1122
1123 void
1124 glTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1125                  GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
1126                  GLenum format, GLenum type, const GLvoid *pixels)
1127 {
1128         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1129
1130         GLWRAP_DEFER (glTexSubImage3D, target, level, xoffset, yoffset,
1131                       zoffset, width, height, depth, format, type, pixels);
1132
1133         RESTORE_METRICS_OP ();
1134 }
1135
1136 void
1137 glTexSubImage3DEXT (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1138                     GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
1139                     GLenum format, GLenum type, const GLvoid *pixels)
1140 {
1141         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1142
1143         GLWRAP_DEFER (glTexSubImage3DEXT, target, level, xoffset, yoffset,
1144                       zoffset, width, height, depth, format, type, pixels);
1145
1146         RESTORE_METRICS_OP ();
1147 }
1148
1149 void
1150 glTexSubImage4DSGIS (GLenum target, GLint level, GLint xoffset, GLint yoffset,
1151                      GLint zoffset, GLint woffset, GLsizei width,
1152                      GLsizei height, GLsizei depth, GLsizei size4d,
1153                      GLenum format, GLenum type, const GLvoid *pixels)
1154 {
1155         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1156
1157         GLWRAP_DEFER (glTexSubImage4DSGIS, target, level, xoffset,
1158                       yoffset, zoffset, woffset, width, height,
1159                       depth, size4d, format, type, pixels);
1160
1161         RESTORE_METRICS_OP ();
1162 }
1163
1164 void
1165 glCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
1166                                 GLenum internalformat, GLsizei width,
1167                                 GLint border, GLsizei imageSize,
1168                                 const GLvoid *bits)
1169 {
1170         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1171
1172         GLWRAP_DEFER (glCompressedMultiTexImage1DEXT, texunit, target,
1173                       level, internalformat, width, border, imageSize, bits);
1174
1175         RESTORE_METRICS_OP ();
1176 }
1177
1178 void
1179 glCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
1180                                 GLenum internalformat, GLsizei width,
1181                                 GLsizei height, GLint border,
1182                                 GLsizei imageSize, const GLvoid *bits)
1183 {
1184         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1185
1186         GLWRAP_DEFER (glCompressedMultiTexImage2DEXT, texunit, target, level,
1187                       internalformat, width, height, border, imageSize, bits);
1188
1189         RESTORE_METRICS_OP ();
1190 }
1191
1192 void
1193 glCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level,
1194                                 GLenum internalformat, GLsizei width,
1195                                 GLsizei height, GLsizei depth, GLint border,
1196                                 GLsizei imageSize, const GLvoid *bits)
1197 {
1198         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1199
1200         GLWRAP_DEFER (glCompressedMultiTexImage3DEXT, texunit, target,
1201                       level, internalformat, width, height, depth,
1202                       border, imageSize, bits);
1203
1204         RESTORE_METRICS_OP ();
1205 }
1206
1207 void
1208 glCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
1209                                    GLint xoffset, GLsizei width, GLenum format,
1210                                    GLsizei imageSize, const GLvoid *bits)
1211 {
1212         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1213
1214         GLWRAP_DEFER (glCompressedMultiTexSubImage1DEXT, texunit, target,
1215                       level, xoffset, width, format, imageSize, bits);
1216
1217         RESTORE_METRICS_OP ();
1218 }
1219
1220 void
1221 glCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
1222                                    GLint xoffset, GLint yoffset, GLsizei width,
1223                                    GLsizei height, GLenum format,
1224                                    GLsizei imageSize, const GLvoid *bits)
1225 {
1226         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1227
1228         GLWRAP_DEFER (glCompressedMultiTexSubImage2DEXT, texunit, target, level,
1229                       xoffset, yoffset, width, height, format, imageSize, bits);
1230
1231         RESTORE_METRICS_OP ();
1232 }
1233
1234 void
1235 glCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
1236                                    GLint xoffset, GLint yoffset, GLint zoffset,
1237                                    GLsizei width, GLsizei height, GLsizei depth,
1238                                    GLenum format, GLsizei imageSize,
1239                                    const GLvoid *bits)
1240 {
1241         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1242
1243         GLWRAP_DEFER (glCompressedMultiTexSubImage3DEXT, texunit, target,
1244                       level, xoffset, yoffset, zoffset, width, height,
1245                       depth, format, imageSize, bits);
1246
1247         RESTORE_METRICS_OP ();
1248 }
1249
1250 void
1251 glCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat,
1252                         GLsizei width, GLint border, GLsizei imageSize,
1253                         const GLvoid *data)
1254 {
1255         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1256
1257         GLWRAP_DEFER (glCompressedTexImage1D, target, level,
1258                       internalformat, width, border, imageSize, data);
1259
1260         RESTORE_METRICS_OP ();
1261 }
1262
1263 void
1264 glCompressedTexImage1DARB (GLenum target, GLint level, GLenum internalformat,
1265                            GLsizei width, GLint border, GLsizei imageSize,
1266                            const GLvoid *data)
1267 {
1268         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1269
1270         GLWRAP_DEFER (glCompressedTexImage1DARB, target, level, internalformat,
1271                       width, border, imageSize, data);
1272
1273         RESTORE_METRICS_OP ();
1274 }
1275
1276 void
1277 glCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat,
1278                         GLsizei width, GLsizei height, GLint border,
1279                         GLsizei imageSize, const GLvoid *data)
1280 {
1281         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1282
1283         GLWRAP_DEFER (glCompressedTexImage2D, target, level, internalformat,
1284                       width, height, border, imageSize, data);
1285
1286         RESTORE_METRICS_OP ();
1287 }
1288
1289 void
1290 glCompressedTexImage2DARB (GLenum target, GLint level, GLenum internalformat,
1291                            GLsizei width, GLsizei height, GLint border,
1292                            GLsizei imageSize, const GLvoid *data)
1293 {
1294         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1295
1296         GLWRAP_DEFER (glCompressedTexImage2DARB, target, level, internalformat,
1297                       width, height, border, imageSize, data);
1298
1299         RESTORE_METRICS_OP ();
1300 }
1301
1302 void
1303 glCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat,
1304                         GLsizei width, GLsizei height, GLsizei depth,
1305                         GLint border, GLsizei imageSize, const GLvoid *data)
1306 {
1307         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1308
1309         GLWRAP_DEFER (glCompressedTexImage3D, target, level, internalformat,
1310                       width, height, depth, border, imageSize, data);
1311
1312         RESTORE_METRICS_OP ();
1313 }
1314
1315 void
1316 glCompressedTexImage3DARB (GLenum target, GLint level, GLenum internalformat,
1317                            GLsizei width, GLsizei height, GLsizei depth,
1318                            GLint border, GLsizei imageSize, const GLvoid *data)
1319 {
1320         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1321
1322         GLWRAP_DEFER (glCompressedTexImage3DARB, target, level, internalformat,
1323                       width, height, depth, border, imageSize, data);
1324
1325         RESTORE_METRICS_OP ();
1326 }
1327
1328 void
1329 glCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset,
1330                            GLsizei width, GLenum format, GLsizei imageSize,
1331                            const GLvoid *data)
1332 {
1333         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1334
1335         GLWRAP_DEFER (glCompressedTexSubImage1D, target, level, xoffset,
1336                       width, format, imageSize, data);
1337
1338         RESTORE_METRICS_OP ();
1339 }
1340
1341 void
1342 glCompressedTexSubImage1DARB (GLenum target, GLint level, GLint xoffset,
1343                               GLsizei width, GLenum format, GLsizei imageSize,
1344                               const GLvoid *data)
1345 {
1346         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1347
1348         GLWRAP_DEFER (glCompressedTexSubImage1DARB, target, level, xoffset,
1349                       width, format, imageSize, data);
1350
1351         RESTORE_METRICS_OP ();
1352 }
1353
1354 void
1355 glCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset,
1356                            GLint yoffset, GLsizei width, GLsizei height,
1357                            GLenum format, GLsizei imageSize, const GLvoid *data)
1358 {
1359         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1360
1361         GLWRAP_DEFER (glCompressedTexSubImage2D, target, level, xoffset,
1362                       yoffset, width, height, format, imageSize, data);
1363
1364         RESTORE_METRICS_OP ();
1365 }
1366
1367 void
1368 glCompressedTexSubImage2DARB (GLenum target, GLint level, GLint xoffset,
1369                               GLint yoffset, GLsizei width, GLsizei height,
1370                               GLenum format, GLsizei imageSize,
1371                               const GLvoid *data)
1372 {
1373         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1374
1375         GLWRAP_DEFER (glCompressedTexSubImage2DARB, target, level, xoffset,
1376                       yoffset, width, height, format, imageSize, data);
1377
1378         RESTORE_METRICS_OP ();
1379 }
1380
1381 void
1382 glCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset,
1383                            GLint yoffset, GLint zoffset, GLsizei width,
1384                            GLsizei height, GLsizei depth, GLenum format,
1385                            GLsizei imageSize, const GLvoid *data)
1386 {
1387         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1388
1389         GLWRAP_DEFER (glCompressedTexSubImage3D, target, level, xoffset,
1390                       yoffset, zoffset, width, height, depth, format,
1391                       imageSize, data);
1392
1393         RESTORE_METRICS_OP ();
1394 }
1395
1396 void
1397 glCompressedTexSubImage3DARB (GLenum target, GLint level, GLint xoffset,
1398                               GLint yoffset, GLint zoffset, GLsizei width,
1399                               GLsizei height, GLsizei depth, GLenum format,
1400                               GLsizei imageSize, const GLvoid *data)
1401 {
1402         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1403
1404         GLWRAP_DEFER (glCompressedTexSubImage3DARB, target, level, xoffset,
1405                       yoffset, zoffset, width, height, depth, format,
1406                       imageSize, data);
1407
1408         RESTORE_METRICS_OP ();
1409 }
1410
1411 void
1412 glCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level,
1413                                GLenum internalformat, GLsizei width,
1414                                GLint border, GLsizei imageSize,
1415                                const GLvoid *bits)
1416 {
1417         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1418
1419         GLWRAP_DEFER (glCompressedTextureImage1DEXT, texture, target, level,
1420                       internalformat, width, border, imageSize, bits);
1421
1422         RESTORE_METRICS_OP ();
1423 }
1424
1425 void
1426 glCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level,
1427                                GLenum internalformat, GLsizei width,
1428                                GLsizei height, GLint border,
1429                                GLsizei imageSize, const GLvoid *bits)
1430 {
1431         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1432
1433         GLWRAP_DEFER (glCompressedTextureImage2DEXT, texture, target, level,
1434                       internalformat, width, height, border, imageSize, bits);
1435
1436         RESTORE_METRICS_OP ();
1437 }
1438
1439 void
1440 glCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level,
1441                                GLenum internalformat, GLsizei width,
1442                                GLsizei height, GLsizei depth, GLint border,
1443                                GLsizei imageSize, const GLvoid *bits)
1444 {
1445         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1446
1447         GLWRAP_DEFER (glCompressedTextureImage3DEXT, texture, target,
1448                       level, internalformat, width, height, depth,
1449                       border, imageSize, bits);
1450
1451         RESTORE_METRICS_OP ();
1452 }
1453
1454 void
1455 glCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level,
1456                                   GLint xoffset, GLsizei width, GLenum format,
1457                                   GLsizei imageSize, const GLvoid *bits)
1458 {
1459         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1460
1461         GLWRAP_DEFER (glCompressedTextureSubImage1DEXT, texture, target,
1462                       level, xoffset, width, format, imageSize, bits);
1463
1464         RESTORE_METRICS_OP ();
1465 }
1466
1467 void
1468 glCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level,
1469                                   GLint xoffset, GLint yoffset, GLsizei width,
1470                                   GLsizei height, GLenum format,
1471                                   GLsizei imageSize, const GLvoid *bits)
1472 {
1473         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1474
1475         GLWRAP_DEFER (glCompressedTextureSubImage2DEXT, texture, target, level,
1476                       xoffset, yoffset, width, height, format, imageSize, bits);
1477
1478         RESTORE_METRICS_OP ();
1479 }
1480
1481 void
1482 glCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level,
1483                                   GLint xoffset, GLint yoffset, GLint zoffset,
1484                                   GLsizei width, GLsizei height, GLsizei depth,
1485                                   GLenum format, GLsizei imageSize,
1486                                   const GLvoid *bits)
1487 {
1488         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1489
1490         GLWRAP_DEFER (glCompressedTextureSubImage3DEXT, texture, target,
1491                       level, xoffset, yoffset, zoffset, width, height,
1492                       depth, format, imageSize, bits);
1493
1494         RESTORE_METRICS_OP ();
1495 }
1496
1497 void
1498 glMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level,
1499                       GLenum internalformat, GLsizei width, GLint border,
1500                       GLenum format, GLenum type, const GLvoid *pixels)
1501 {
1502         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1503
1504         GLWRAP_DEFER (glMultiTexImage1DEXT, texunit, target, level,
1505                       internalformat, width, border, format, type, pixels);
1506
1507         RESTORE_METRICS_OP ();
1508 }
1509
1510 void
1511 glMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level,
1512                       GLenum internalformat, GLsizei width, GLsizei height,
1513                       GLint border, GLenum format, GLenum type,
1514                       const GLvoid *pixels)
1515 {
1516         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1517
1518         GLWRAP_DEFER (glMultiTexImage2DEXT, texunit, target, level,
1519                       internalformat, width, height, border, format,
1520                       type, pixels);
1521
1522         RESTORE_METRICS_OP ();
1523 }
1524
1525 void
1526 glMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level,
1527                       GLenum internalformat, GLsizei width, GLsizei height,
1528                       GLsizei depth, GLint border, GLenum format,
1529                       GLenum type, const GLvoid *pixels)
1530 {
1531         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1532
1533         GLWRAP_DEFER (glMultiTexImage3DEXT, texunit, target, level,
1534                       internalformat, width, height, depth, border,
1535                       format, type, pixels);
1536
1537         RESTORE_METRICS_OP ();
1538 }
1539
1540 void
1541 glMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level,
1542                          GLint xoffset, GLsizei width, GLenum format,
1543                          GLenum type, const GLvoid *pixels)
1544 {
1545         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1546
1547         GLWRAP_DEFER (glMultiTexSubImage1DEXT, texunit, target, level,
1548                       xoffset, width, format, type, pixels);
1549
1550         RESTORE_METRICS_OP ();
1551 }
1552
1553 void
1554 glMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level,
1555                          GLint xoffset, GLint yoffset, GLsizei width,
1556                          GLsizei height, GLenum format, GLenum type,
1557                          const GLvoid *pixels)
1558 {
1559         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1560
1561         GLWRAP_DEFER (glMultiTexSubImage2DEXT, texunit, target, level, xoffset,
1562                       yoffset, width, height, format, type, pixels);
1563
1564         RESTORE_METRICS_OP ();
1565 }
1566
1567 void
1568 glMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level,
1569                          GLint xoffset, GLint yoffset, GLint zoffset,
1570                          GLsizei width, GLsizei height, GLsizei depth,
1571                          GLenum format, GLenum type, const GLvoid *pixels)
1572 {
1573         SAVE_THEN_SWITCH_METRICS_OP (METRICS_OP_TEX_IMAGE);
1574
1575         GLWRAP_DEFER (glMultiTexSubImage3DEXT, texunit, target, level,
1576                       xoffset, yoffset, zoffset, width, height, depth,
1577                       format, type, pixels);
1578
1579         RESTORE_METRICS_OP ();
1580 }