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