git.cworth.org Git - apitrace/blob - glsize.hpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2011 Jose Fonseca
   4  * Copyright 2010 VMware, Inc.
   5  * Copyright 2004 IBM Corporation
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the next
  16  * paragraph) shall be included in all copies or substantial portions of the
  17  * Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  22  * AUTHORS,
  23  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  25  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30 /*
  31  * Auxiliary functions to compute the size of array/blob arguments, depending.
  32  */
  33
  34 #ifndef _GL_SIZE_HPP_
  35 #define _GL_SIZE_HPP_
  36
  37
  38 #include <string.h>
  39
  40 #include "os.hpp"
  41 #include "glimports.hpp"
  42
  43
  44 static inline size_t
  45 __gl_type_size(GLenum type)
  46 {
  47     switch (type) {
  48     case GL_BOOL:
  49     case GL_BYTE:
  50     case GL_UNSIGNED_BYTE:
  51         return 1;
  52     case GL_SHORT:
  53     case GL_UNSIGNED_SHORT:
  54     case GL_2_BYTES:
  55     case GL_HALF_FLOAT:
  56         return 2;
  57     case GL_3_BYTES:
  58         return 3;
  59     case GL_INT:
  60     case GL_UNSIGNED_INT:
  61     case GL_FLOAT:
  62     case GL_4_BYTES:
  63         return 4;
  64     case GL_DOUBLE:
  65         return 8;
  66     default:
  67         os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
  68         return 0;
  69     }
  70 }
  71
  72 static inline void
  73 __gl_uniform_size(GLenum type, GLenum &elemType, GLint &numElems) {
  74     switch (type) {
  75     case GL_FLOAT:
  76         elemType = GL_FLOAT;
  77         numElems = 1;
  78         break;
  79     case GL_FLOAT_VEC2:
  80         elemType = GL_FLOAT;
  81         numElems = 2;
  82         break;
  83     case GL_FLOAT_VEC3:
  84         elemType = GL_FLOAT;
  85         numElems = 3;
  86         break;
  87     case GL_FLOAT_VEC4:
  88         elemType = GL_FLOAT;
  89         numElems = 4;
  90         break;
  91     case GL_DOUBLE:
  92         elemType = GL_DOUBLE;
  93         numElems = 1;
  94         break;
  95     case GL_DOUBLE_VEC2:
  96         elemType = GL_DOUBLE;
  97         numElems = 2;
  98         break;
  99     case GL_DOUBLE_VEC3:
 100         elemType = GL_DOUBLE;
 101         numElems = 3;
 102         break;
 103     case GL_DOUBLE_VEC4:
 104         elemType = GL_DOUBLE;
 105         numElems = 4;
 106         break;
 107     case GL_INT:
 108         elemType = GL_INT;
 109         numElems = 1;
 110         break;
 111     case GL_INT_VEC2:
 112         elemType = GL_INT;
 113         numElems = 2;
 114         break;
 115     case GL_INT_VEC3:
 116         elemType = GL_INT;
 117         numElems = 3;
 118         break;
 119     case GL_INT_VEC4:
 120         elemType = GL_INT;
 121         numElems = 4;
 122         break;
 123     case GL_UNSIGNED_INT:
 124         elemType = GL_UNSIGNED_INT;
 125         numElems = 1;
 126         break;
 127     case GL_UNSIGNED_INT_VEC2:
 128         elemType = GL_UNSIGNED_INT;
 129         numElems = 2;
 130         break;
 131     case GL_UNSIGNED_INT_VEC3:
 132         elemType = GL_UNSIGNED_INT;
 133         numElems = 3;
 134         break;
 135     case GL_UNSIGNED_INT_VEC4:
 136         elemType = GL_UNSIGNED_INT;
 137         numElems = 4;
 138         break;
 139     case GL_BOOL:
 140         elemType = GL_BOOL;
 141         numElems = 1;
 142         break;
 143     case GL_BOOL_VEC2:
 144         elemType = GL_BOOL;
 145         numElems = 2;
 146         break;
 147     case GL_BOOL_VEC3:
 148         elemType = GL_BOOL;
 149         numElems = 3;
 150         break;
 151     case GL_BOOL_VEC4:
 152         elemType = GL_BOOL;
 153         numElems = 4;
 154         break;
 155     case GL_FLOAT_MAT2:
 156         elemType = GL_FLOAT;
 157         numElems = 2*2;
 158         break;
 159     case GL_FLOAT_MAT3:
 160         elemType = GL_FLOAT;
 161         numElems = 3*3;
 162         break;
 163     case GL_FLOAT_MAT4:
 164         elemType = GL_FLOAT;
 165         numElems = 4*4;
 166         break;
 167     case GL_FLOAT_MAT2x3:
 168         elemType = GL_FLOAT;
 169         numElems = 2*3;
 170         break;
 171     case GL_FLOAT_MAT2x4:
 172         elemType = GL_FLOAT;
 173         numElems = 2*4;
 174         break;
 175     case GL_FLOAT_MAT3x2:
 176         elemType = GL_FLOAT;
 177         numElems = 3*2;
 178         break;
 179     case GL_FLOAT_MAT3x4:
 180         elemType = GL_FLOAT;
 181         numElems = 3*4;
 182         break;
 183     case GL_FLOAT_MAT4x2:
 184         elemType = GL_FLOAT;
 185         numElems = 4*2;
 186         break;
 187     case GL_FLOAT_MAT4x3:
 188         elemType = GL_FLOAT;
 189         numElems = 4*3;
 190         break;
 191     case GL_DOUBLE_MAT2:
 192         elemType = GL_DOUBLE;
 193         numElems = 2*2;
 194         break;
 195     case GL_DOUBLE_MAT3:
 196         elemType = GL_DOUBLE;
 197         numElems = 3*3;
 198         break;
 199     case GL_DOUBLE_MAT4:
 200         elemType = GL_DOUBLE;
 201         numElems = 4*4;
 202         break;
 203     case GL_DOUBLE_MAT2x3:
 204         elemType = GL_DOUBLE;
 205         numElems = 2*3;
 206         break;
 207     case GL_DOUBLE_MAT2x4:
 208         elemType = GL_DOUBLE;
 209         numElems = 2*4;
 210         break;
 211     case GL_DOUBLE_MAT3x2:
 212         elemType = GL_DOUBLE;
 213         numElems = 3*2;
 214         break;
 215     case GL_DOUBLE_MAT3x4:
 216         elemType = GL_DOUBLE;
 217         numElems = 3*4;
 218         break;
 219     case GL_DOUBLE_MAT4x2:
 220         elemType = GL_DOUBLE;
 221         numElems = 4*2;
 222         break;
 223     case GL_DOUBLE_MAT4x3:
 224         elemType = GL_DOUBLE;
 225         numElems = 4*3;
 226         break;
 227     case GL_SAMPLER_1D:
 228     case GL_SAMPLER_2D:
 229     case GL_SAMPLER_3D:
 230     case GL_SAMPLER_CUBE:
 231     case GL_SAMPLER_1D_SHADOW:
 232     case GL_SAMPLER_2D_SHADOW:
 233     case GL_SAMPLER_1D_ARRAY:
 234     case GL_SAMPLER_2D_ARRAY:
 235     case GL_SAMPLER_CUBE_MAP_ARRAY:
 236     case GL_SAMPLER_1D_ARRAY_SHADOW:
 237     case GL_SAMPLER_2D_ARRAY_SHADOW:
 238     case GL_SAMPLER_2D_MULTISAMPLE:
 239     case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
 240     case GL_SAMPLER_CUBE_SHADOW:
 241     case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
 242     case GL_SAMPLER_BUFFER:
 243     case GL_SAMPLER_2D_RECT:
 244     case GL_SAMPLER_2D_RECT_SHADOW:
 245     case GL_INT_SAMPLER_1D:
 246     case GL_INT_SAMPLER_2D:
 247     case GL_INT_SAMPLER_3D:
 248     case GL_INT_SAMPLER_CUBE:
 249     case GL_INT_SAMPLER_1D_ARRAY:
 250     case GL_INT_SAMPLER_2D_ARRAY:
 251     case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
 252     case GL_INT_SAMPLER_2D_MULTISAMPLE:
 253     case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
 254     case GL_INT_SAMPLER_BUFFER:
 255     case GL_INT_SAMPLER_2D_RECT:
 256     case GL_UNSIGNED_INT_SAMPLER_1D:
 257     case GL_UNSIGNED_INT_SAMPLER_2D:
 258     case GL_UNSIGNED_INT_SAMPLER_3D:
 259     case GL_UNSIGNED_INT_SAMPLER_CUBE:
 260     case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
 261     case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
 262     case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
 263     case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
 264     case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
 265     case GL_UNSIGNED_INT_SAMPLER_BUFFER:
 266     case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
 267         elemType = GL_INT;
 268         numElems = 1;
 269         break;
 270     default:
 271         os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
 272         elemType = GL_NONE;
 273         numElems = 0;
 274         return;
 275     }
 276 }
 277
 278 static inline size_t
 279 __glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex)
 280 {
 281     size_t elementSize = size*__gl_type_size(type);
 282     if (!stride) {
 283         stride = (GLsizei)elementSize;
 284     }
 285     return stride*maxIndex + elementSize;
 286 }
 287
 288 #define __glVertexPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 289 #define __glNormalPointer_size(type, stride, maxIndex) __glArrayPointer_size(3, type, stride, maxIndex)
 290 #define __glColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 291 #define __glIndexPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
 292 #define __glTexCoordPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 293 #define __glEdgeFlagPointer_size(stride, maxIndex) __glArrayPointer_size(1, GL_BOOL, stride, maxIndex)
 294 #define __glFogCoordPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
 295 #define __glSecondaryColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 296 #define __glVertexAttribPointer_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 297 #define __glVertexAttribPointerARB_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 298 #define __glVertexAttribPointerNV_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
 299
 300 static inline GLuint
 301 __glDrawArrays_maxindex(GLint first, GLsizei count)
 302 {
 303     if (!count) {
 304         return 0;
 305     }
 306     return first + count - 1;
 307 }
 308
 309 #define __glDrawArraysEXT_maxindex __glDrawArrays_maxindex
 310
 311 static inline GLuint
 312 __glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 313 {
 314     GLvoid *temp = 0;
 315     GLint __element_array_buffer = 0;
 316
 317     if (!count) {
 318         return 0;
 319     }
 320
 321     __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);
 322     if (__element_array_buffer) {
 323         // Read indices from index buffer object
 324         GLintptr offset = (GLintptr)indices;
 325         GLsizeiptr size = count*__gl_type_size(type);
 326         GLvoid *temp = malloc(size);
 327         if (!temp) {
 328             return 0;
 329         }
 330         memset(temp, 0, size);
 331         __glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, temp);
 332         indices = temp;
 333     } else {
 334         if (!indices) {
 335             return 0;
 336         }
 337     }
 338
 339     GLuint maxindex = 0;
 340     GLsizei i;
 341     if (type == GL_UNSIGNED_BYTE) {
 342         const GLubyte *p = (const GLubyte *)indices;
 343         for (i = 0; i < count; ++i) {
 344             if (p[i] > maxindex) {
 345                 maxindex = p[i];
 346             }
 347         }
 348     } else if (type == GL_UNSIGNED_SHORT) {
 349         const GLushort *p = (const GLushort *)indices;
 350         for (i = 0; i < count; ++i) {
 351             if (p[i] > maxindex) {
 352                 maxindex = p[i];
 353             }
 354         }
 355     } else if (type == GL_UNSIGNED_INT) {
 356         const GLuint *p = (const GLuint *)indices;
 357         for (i = 0; i < count; ++i) {
 358             if (p[i] > maxindex) {
 359                 maxindex = p[i];
 360             }
 361         }
 362     } else {
 363         os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
 364     }
 365
 366     if (__element_array_buffer) {
 367         free(temp);
 368     }
 369
 370     maxindex += basevertex;
 371
 372     return maxindex;
 373 }
 374
 375 #define __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
 376
 377 #define __glDrawElements_maxindex(count, type, indices) __glDrawElementsBaseVertex_maxindex(count, type, indices, 0);
 378 #define __glDrawRangeElements_maxindex(start, end, count, type, indices) __glDrawElements_maxindex(count, type, indices)
 379 #define __glDrawRangeElementsEXT_maxindex __glDrawRangeElements_maxindex
 380
 381 /* FIXME take in consideration instancing */
 382 #define __glDrawArraysInstanced_maxindex(first, count, primcount) __glDrawArrays_maxindex(first, count)
 383 #define __glDrawElementsInstanced_maxindex(count, type, indices, primcount) __glDrawElements_maxindex(count, type, indices)
 384 #define __glDrawElementsInstancedBaseVertex_maxindex(count, type, indices, primcount, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
 385 #define __glDrawRangeElementsInstanced_maxindex(start, end, count, type, indices, primcount) __glDrawRangeElements_maxindex(start, end, count, type, indices)
 386 #define __glDrawRangeElementsInstancedBaseVertex_maxindex(start, end, count, type, indices, primcount, basevertex) __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex)
 387
 388 #define __glDrawArraysInstancedBaseInstance_maxindex(first, count, primcount, baseinstance) __glDrawArrays_maxindex(first, count)
 389 #define __glDrawElementsInstancedBaseInstance_maxindex(count, type, indices, primcount, baseinstance) __glDrawElements_maxindex(count, type, indices)
 390 #define __glDrawElementsInstancedBaseVertexBaseInstance_maxindex(count, type, indices, primcount, basevertex, baseinstance) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
 391
 392 #define __glDrawArraysInstancedARB_maxindex __glDrawArraysInstanced_maxindex
 393 #define __glDrawElementsInstancedARB_maxindex __glDrawElementsInstanced_maxindex
 394 #define __glDrawArraysInstancedEXT_maxindex __glDrawArraysInstanced_maxindex
 395 #define __glDrawElementsInstancedEXT_maxindex __glDrawElementsInstanced_maxindex
 396
 397 static inline GLuint
 398 __glDrawArraysIndirect_maxindex(const GLvoid *indirect) {
 399     os::log("apitrace: warning: %s: unsupported\n", __FUNCTION__);
 400     return 0;
 401 }
 402
 403 static inline GLuint
 404 __glDrawElementsIndirect_maxindex(GLenum type, const GLvoid *indirect) {
 405     os::log("apitrace: warning: %s: unsupported\n", __FUNCTION__);
 406     return 0;
 407 }
 408
 409 static inline GLuint
 410 __glMultiDrawArrays_maxindex(const GLint *first, const GLsizei *count, GLsizei primcount) {
 411     GLuint maxindex = 0;
 412     for (GLsizei prim = 0; prim < primcount; ++prim) {
 413         GLuint maxindex_prim = __glDrawArrays_maxindex(first[prim], count[prim]);
 414         maxindex = std::max(maxindex, maxindex_prim);
 415     }
 416     return maxindex;
 417 }
 418
 419 static inline GLuint
 420 __glMultiDrawElements_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
 421     GLuint maxindex = 0;
 422     for (GLsizei prim = 0; prim < primcount; ++prim) {
 423         GLuint maxindex_prim = __glDrawElements_maxindex(count[prim], type, indices[prim]);
 424         maxindex = std::max(maxindex, maxindex_prim);
 425     }
 426     return maxindex;
 427 }
 428
 429 static inline GLuint
 430 __glMultiDrawElementsBaseVertex_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, const GLint * basevertex) {
 431     GLuint maxindex = 0;
 432     for (GLsizei prim = 0; prim < primcount; ++prim) {
 433         GLuint maxindex_prim = __glDrawElementsBaseVertex_maxindex(count[prim], type, indices[prim], basevertex[prim]);
 434         maxindex = std::max(maxindex, maxindex_prim);
 435     }
 436     return maxindex;
 437 }
 438
 439 #define __glMultiDrawArraysEXT_maxindex __glMultiDrawArrays_maxindex
 440 #define __glMultiDrawElementsEXT_maxindex __glMultiDrawElements_maxindex
 441
 442 #define __glMultiModeDrawArraysIBM_maxindex(first, count, primcount, modestride) __glMultiDrawArrays_maxindex(first, count, primcount)
 443 #define __glMultiModeDrawElementsIBM_maxindex(count, type, indices, primcount, modestride) __glMultiDrawElements_maxindex(count, type, (const GLvoid **)indices, primcount)
 444
 445
 446 static inline size_t
 447 __glCallLists_size(GLsizei n, GLenum type)
 448 {
 449     return n*__gl_type_size(type);
 450 }
 451
 452 static inline size_t
 453 __glMap1d_size(GLenum target, GLint stride, GLint order)
 454 {
 455     if (order < 1) {
 456         return 0;
 457     }
 458
 459     GLint channels;
 460     switch (target) {
 461     case GL_MAP1_INDEX:
 462     case GL_MAP1_TEXTURE_COORD_1:
 463         channels = 1;
 464         break;
 465     case GL_MAP1_TEXTURE_COORD_2:
 466         channels = 2;
 467         break;
 468     case GL_MAP1_NORMAL:
 469     case GL_MAP1_TEXTURE_COORD_3:
 470     case GL_MAP1_VERTEX_3:
 471         channels = 3;
 472         break;
 473     case GL_MAP1_COLOR_4:
 474     case GL_MAP1_TEXTURE_COORD_4:
 475     case GL_MAP1_VERTEX_4:
 476         channels = 4;
 477         break;
 478     default:
 479         os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
 480         return 0;
 481     }
 482
 483     if (stride < channels) {
 484         return 0;
 485     }
 486
 487     return channels + stride * (order - 1);
 488 }
 489
 490 #define __glMap1f_size __glMap1d_size
 491
 492 static inline size_t
 493 __glMap2d_size(GLenum target, GLint ustride, GLint uorder, GLint vstride, GLint vorder)
 494 {
 495     if (uorder < 1 || vorder < 1) {
 496         return 0;
 497     }
 498
 499     GLint channels;
 500     switch (target) {
 501     case GL_MAP2_INDEX:
 502     case GL_MAP2_TEXTURE_COORD_1:
 503         channels = 1;
 504         break;
 505     case GL_MAP2_TEXTURE_COORD_2:
 506         channels = 2;
 507         break;
 508     case GL_MAP2_NORMAL:
 509     case GL_MAP2_TEXTURE_COORD_3:
 510     case GL_MAP2_VERTEX_3:
 511         channels = 3;
 512         break;
 513     case GL_MAP2_COLOR_4:
 514     case GL_MAP2_TEXTURE_COORD_4:
 515     case GL_MAP2_VERTEX_4:
 516         channels = 4;
 517         break;
 518     default:
 519         os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
 520         return 0;
 521     }
 522
 523     if (ustride < channels || vstride < channels) {
 524         return 0;
 525     }
 526
 527     return channels +
 528            ustride * (uorder - 1) +
 529            vstride * (vorder - 1);
 530 }
 531
 532 #define __glMap2f_size __glMap2d_size
 533
 534 static inline unsigned
 535 __gl_format_channels(GLenum format) {
 536     switch (format) {
 537     case GL_COLOR_INDEX:
 538     case GL_RED:
 539     case GL_GREEN:
 540     case GL_BLUE:
 541     case GL_ALPHA:
 542     case GL_INTENSITY:
 543     case GL_LUMINANCE:
 544     case GL_DEPTH_COMPONENT:
 545     case GL_STENCIL_INDEX:
 546         return 1;
 547     case GL_DEPTH_STENCIL:
 548     case GL_LUMINANCE_ALPHA:
 549     case GL_RG:
 550     case GL_HILO_NV:
 551     case GL_DSDT_NV:
 552         return 2;
 553     case GL_RGB:
 554     case GL_BGR:
 555     case GL_DSDT_MAG_NV:
 556         return 3;
 557     case GL_RGBA:
 558     case GL_BGRA:
 559     case GL_ABGR_EXT:
 560     case GL_CMYK_EXT:
 561     case GL_DSDT_MAG_VIB_NV:
 562         return 4;
 563     case GL_CMYKA_EXT:
 564         return 5;
 565     default:
 566         os::log("apitrace: warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format);
 567         return 0;
 568     }
 569 }
 570
 571 template<class X>
 572 static inline bool
 573 _is_pot(X x) {
 574     return (x & (x - 1)) == 0;
 575 }
 576
 577 template<class X, class Y>
 578 static inline X
 579 _align(X x, Y y) {
 580     return (x + (y - 1)) & ~(y - 1);
 581 }
 582
 583 static inline size_t
 584 __gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth) {
 585     unsigned num_channels = __gl_format_channels(format);
 586
 587     unsigned bits_per_pixel;
 588     switch (type) {
 589     case GL_BITMAP:
 590         bits_per_pixel = 1;
 591         break;
 592     case GL_BYTE:
 593     case GL_UNSIGNED_BYTE:
 594         bits_per_pixel = 8 * num_channels;
 595         break;
 596     case GL_SHORT:
 597     case GL_UNSIGNED_SHORT:
 598     case GL_HALF_FLOAT:
 599         bits_per_pixel = 16 * num_channels;
 600         break;
 601     case GL_INT:
 602     case GL_UNSIGNED_INT:
 603     case GL_FLOAT:
 604         bits_per_pixel = 32 * num_channels;
 605         break;
 606     case GL_UNSIGNED_BYTE_3_3_2:
 607     case GL_UNSIGNED_BYTE_2_3_3_REV:
 608         bits_per_pixel = 8;
 609         break;
 610     case GL_UNSIGNED_SHORT_4_4_4_4:
 611     case GL_UNSIGNED_SHORT_4_4_4_4_REV:
 612     case GL_UNSIGNED_SHORT_5_5_5_1:
 613     case GL_UNSIGNED_SHORT_1_5_5_5_REV:
 614     case GL_UNSIGNED_SHORT_5_6_5:
 615     case GL_UNSIGNED_SHORT_5_6_5_REV:
 616     case GL_UNSIGNED_SHORT_8_8_MESA:
 617     case GL_UNSIGNED_SHORT_8_8_REV_MESA:
 618         bits_per_pixel = 16;
 619         break;
 620     case GL_UNSIGNED_INT_8_8_8_8:
 621     case GL_UNSIGNED_INT_8_8_8_8_REV:
 622     case GL_UNSIGNED_INT_10_10_10_2:
 623     case GL_UNSIGNED_INT_2_10_10_10_REV:
 624     case GL_UNSIGNED_INT_24_8:
 625     case GL_UNSIGNED_INT_10F_11F_11F_REV:
 626     case GL_UNSIGNED_INT_5_9_9_9_REV:
 627     case GL_UNSIGNED_INT_S8_S8_8_8_NV:
 628     case GL_UNSIGNED_INT_8_8_S8_S8_REV_NV:
 629         bits_per_pixel = 32;
 630         break;
 631     case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
 632         bits_per_pixel = 64;
 633         break;
 634     default:
 635         os::log("apitrace: warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type);
 636         bits_per_pixel = 0;
 637         break;
 638     }
 639
 640     GLint alignment = 4;
 641     GLint row_length = 0;
 642     GLint image_height = 0;
 643     GLint skip_rows = 0;
 644     GLint skip_pixels = 0;
 645     GLint skip_images = 0;
 646
 647     __glGetIntegerv(GL_UNPACK_ALIGNMENT,    &alignment);
 648     __glGetIntegerv(GL_UNPACK_ROW_LENGTH,   &row_length);
 649     __glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &image_height);
 650     __glGetIntegerv(GL_UNPACK_SKIP_ROWS,    &skip_rows);
 651     __glGetIntegerv(GL_UNPACK_SKIP_PIXELS,  &skip_pixels);
 652     __glGetIntegerv(GL_UNPACK_SKIP_IMAGES,  &skip_images);
 653
 654     if (row_length <= 0) {
 655         row_length = width;
 656     }
 657
 658     size_t row_stride = (row_length*bits_per_pixel + 7)/8;
 659
 660     if ((GLint)bits_per_pixel < alignment*8 &&
 661         (bits_per_pixel & 7) == 0 &&
 662         _is_pot(bits_per_pixel)) {
 663         row_stride = _align(row_stride, alignment);
 664     }
 665
 666     if (image_height <= 0) {
 667         image_height = height;
 668     }
 669
 670     /* XXX: GL_UNPACK_IMAGE_HEIGHT and GL_UNPACK_SKIP_IMAGES should probably
 671      * not be considered for pixel rectangles. */
 672
 673     size_t image_stride = image_height*row_stride;
 674
 675     size_t size = depth*image_stride;
 676
 677     size += (skip_pixels*bits_per_pixel + 7)/8;
 678     size += skip_rows*row_stride;
 679     size += skip_images*image_stride;
 680
 681     return size;
 682 }
 683
 684 #define __glTexImage3D_size(format, type, width, height, depth) __gl_image_size(format, type, width, height, depth)
 685 #define __glTexImage2D_size(format, type, width, height)        __gl_image_size(format, type, width, height, 1)
 686 #define __glTexImage1D_size(format, type, width)                __gl_image_size(format, type, width, 1, 1)
 687
 688 #define __glTexSubImage3D_size(format, type, width, height, depth) __glTexImage3D_size(format, type, width, height, depth)
 689 #define __glTexSubImage2D_size(format, type, width, height)        __glTexImage2D_size(format, type, width, height)
 690 #define __glTexSubImage1D_size(format, type, width)                __glTexImage1D_size(format, type, width)
 691
 692 #define __glTexImage3DEXT_size __glTexImage3D_size
 693 #define __glTexImage2DEXT_size __glTexImage2D_size
 694 #define __glTexImage1DEXT_size __glTexImage1D_size
 695 #define __glTexSubImage3DEXT_size __glTexSubImage3D_size
 696 #define __glTexSubImage2DEXT_size __glTexSubImage2D_size
 697 #define __glTexSubImage1DEXT_size __glTexSubImage1D_size
 698
 699 #define __glTextureImage3DEXT_size __glTexImage3D_size
 700 #define __glTextureImage2DEXT_size __glTexImage2D_size
 701 #define __glTextureImage1DEXT_size __glTexImage1D_size
 702 #define __glTextureSubImage3DEXT_size __glTexSubImage3D_size
 703 #define __glTextureSubImage2DEXT_size __glTexSubImage2D_size
 704 #define __glTextureSubImage1DEXT_size __glTexSubImage1D_size
 705
 706 #define __glMultiTexImage3DEXT_size __glTexImage3D_size
 707 #define __glMultiTexImage2DEXT_size __glTexImage2D_size
 708 #define __glMultiTexImage1DEXT_size __glTexImage1D_size
 709 #define __glMultiTexSubImage3DEXT_size __glTexSubImage3D_size
 710 #define __glMultiTexSubImage2DEXT_size __glTexSubImage2D_size
 711 #define __glMultiTexSubImage1DEXT_size __glTexSubImage1D_size
 712
 713 #define __glDrawPixels_size(format, type, width, height) __glTexImage2D_size(format, type, width, height)
 714 #define __glConvolutionFilter1D_size(format, type, width) __glTexImage1D_size(format, type, width)
 715 #define __glConvolutionFilter2D_size(format, type, width, height) __glTexImage2D_size(format, type, width, height)
 716 #define __glColorTable_size(format, type, width) __glTexImage1D_size(format, type, width)
 717 #define __glColorSubTable_size(format, type, count) __glColorTable_size(format, type, count)
 718
 719 #define __glBitmap_size(width, height) __glTexImage2D_size(GL_COLOR_INDEX, GL_BITMAP, width, height)
 720 #define __glPolygonStipple_size() __glBitmap_size(32, 32)
 721
 722 static inline size_t
 723 __glClearBuffer_size(GLenum buffer)
 724 {
 725     switch (buffer) {
 726     case GL_COLOR:
 727     case GL_FRONT:
 728     case GL_BACK:
 729     case GL_LEFT:
 730     case GL_RIGHT:
 731     case GL_FRONT_AND_BACK:
 732         return 4;
 733     case GL_DEPTH:
 734     case GL_STENCIL:
 735         return 1;
 736     default:
 737         os::log("apitrace: warning: %s: unexpected buffer GLenum 0x%04X\n", __FUNCTION__, buffer);
 738         return 0;
 739     }
 740 }
 741
 742 /*
 743  * 0 terminated integer/float attribute list.
 744  */
 745 template<class T>
 746 static inline size_t
 747 __AttribList_size(const T *pAttribList)
 748 {
 749     size_t size = 0;
 750
 751     if (pAttribList) {
 752         do {
 753             ++size;
 754         } while (*pAttribList++);
 755     }
 756
 757     return size;
 758 }
 759
 760
 761 #endif /* _GL_SIZE_HPP_ */