]> git.cworth.org Git - apitrace/blob - glsize.hpp
Consider glPixelStore state in image size computation.
[apitrace] / glsize.hpp
1 /**************************************************************************
2  *
3  * Copyright 2010 VMware, Inc.
4  * Copyright 2004 IBM Corporation
5  * All Rights Reserved.
6  * 
7  * Permission is hereby granted, free of charge, to any person obtaining a
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sub license,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is furnished to do so, subject to the following conditions:
13  * 
14  * The above copyright notice and this permission notice (including the next
15  * paragraph) shall be included in all copies or substantial portions of the
16  * Software.
17  * 
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
21  * AUTHORS,
22  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
24  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25  * SOFTWARE.
26  *
27  **************************************************************************/
28
29 /*
30  * Auxiliary functions to compute the size of array/blob arguments, depending.
31  */
32
33 #ifndef _GL_SIZE_HPP_
34 #define _GL_SIZE_HPP_
35
36
37 #include "os.hpp"
38 #include "glimports.hpp"
39
40
41 static inline size_t
42 __gl_type_size(GLenum type)
43 {
44     switch (type) {
45     case GL_BOOL:
46     case GL_BYTE:
47     case GL_UNSIGNED_BYTE:
48         return 1;
49     case GL_SHORT:
50     case GL_UNSIGNED_SHORT:
51     case GL_2_BYTES:
52     case GL_HALF_FLOAT:
53         return 2;
54     case GL_3_BYTES:
55         return 3;
56     case GL_INT:
57     case GL_UNSIGNED_INT:
58     case GL_FLOAT:
59     case GL_4_BYTES:
60         return 4;
61     case GL_DOUBLE:
62         return 8;
63     default:
64         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
65         return 0;
66     }
67 }
68
69 static inline size_t
70 __glArrayPointer_size(GLint size, GLenum type, GLsizei stride, GLsizei maxIndex)
71 {
72     size_t elementSize = size*__gl_type_size(type);
73     if (!stride) {
74         stride = (GLsizei)elementSize;
75     }
76     return stride*maxIndex + elementSize;
77 }
78
79 #define __glVertexPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
80 #define __glNormalPointer_size(type, stride, maxIndex) __glArrayPointer_size(3, type, stride, maxIndex)
81 #define __glColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
82 #define __glIndexPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
83 #define __glTexCoordPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
84 #define __glEdgeFlagPointer_size(stride, maxIndex) __glArrayPointer_size(1, GL_BOOL, stride, maxIndex)
85 #define __glFogCoordPointer_size(type, stride, maxIndex) __glArrayPointer_size(1, type, stride, maxIndex)
86 #define __glSecondaryColorPointer_size(size, type, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
87 #define __glVertexAttribPointer_size(size, type, normalized, stride, maxIndex) __glArrayPointer_size(size, type, stride, maxIndex)
88
89 static inline GLuint
90 __glDrawArrays_maxindex(GLint first, GLsizei count)
91 {
92     if (!count) {
93         return 0;
94     }
95     return first + count - 1;
96 }
97
98 #define __glDrawArraysEXT_maxindex __glDrawArrays_maxindex
99
100 static inline GLuint
101 __glDrawElementsBaseVertex_maxindex(GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
102 {
103     GLvoid *temp = 0;
104     GLint __element_array_buffer = 0;
105
106     if (!count) {
107         return 0;
108     }
109     __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);
110     if (__element_array_buffer) {
111         // Read indices from index buffer object
112         GLintptr offset = (GLintptr)indices;
113         GLsizeiptr size = count*__gl_type_size(type);
114         GLvoid *temp = malloc(size);
115         if (!temp) {
116             return 0;
117         }
118         memset(temp, 0, size);
119         __glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, size, temp);
120         indices = temp;
121     } else {
122         if (!indices) {
123             return 0;
124         }
125     }
126
127     GLuint maxindex = 0;
128     GLsizei i;
129     if (type == GL_UNSIGNED_BYTE) {
130         const GLubyte *p = (const GLubyte *)indices;
131         for (i = 0; i < count; ++i) {
132             if (p[i] > maxindex) {
133                 maxindex = p[i];
134             }
135         }
136     } else if (type == GL_UNSIGNED_SHORT) {
137         const GLushort *p = (const GLushort *)indices;
138         for (i = 0; i < count; ++i) {
139             if (p[i] > maxindex) {
140                 maxindex = p[i];
141             }
142         }
143     } else if (type == GL_UNSIGNED_INT) {
144         const GLuint *p = (const GLuint *)indices;
145         for (i = 0; i < count; ++i) {
146             if (p[i] > maxindex) {
147                 maxindex = p[i];
148             }
149         }
150     } else {
151         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
152     }
153
154     if (__element_array_buffer) {
155         free(temp);
156     }
157
158     maxindex += basevertex;
159
160     return maxindex;
161 }
162
163 #define __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
164
165 #define __glDrawElements_maxindex(count, type, indices) __glDrawElementsBaseVertex_maxindex(count, type, indices, 0);
166 #define __glDrawRangeElements_maxindex(start, end, count, type, indices) __glDrawElements_maxindex(count, type, indices)
167 #define __glDrawRangeElementsEXT_maxindex __glDrawRangeElements_maxindex
168
169 #define __glDrawArraysInstanced_maxindex(first, count, primcount) __glDrawArrays_maxindex(first, count)
170 #define __glDrawElementsInstanced_maxindex(count, type, indices, primcount) __glDrawElements_maxindex(count, type, indices)
171 #define __glDrawElementsInstancedBaseVertex_maxindex(count, type, indices, primcount, basevertex) __glDrawElementsBaseVertex_maxindex(count, type, indices, basevertex)
172 #define __glDrawRangeElementsInstanced_maxindex(start, end, count, type, indices, primcount) __glDrawRangeElements_maxindex(start, end, count, type, indices)
173 #define __glDrawRangeElementsInstancedBaseVertex_maxindex(start, end, count, type, indices, primcount, basevertex) __glDrawRangeElementsBaseVertex_maxindex(start, end, count, type, indices, basevertex)
174
175 #define __glDrawArraysInstancedARB_maxindex __glDrawArraysInstanced_maxindex
176 #define __glDrawElementsInstancedARB_maxindex __glDrawElementsInstanced_maxindex
177 #define __glDrawArraysInstancedEXT_maxindex __glDrawArraysInstanced_maxindex
178 #define __glDrawElementsInstancedEXT_maxindex __glDrawElementsInstanced_maxindex
179
180 static inline GLuint
181 __glDrawArraysIndirect_maxindex(const GLvoid *indirect) {
182     OS::DebugMessage("warning: %s: unsupported\n", __FUNCTION__);
183     return 0;
184 }
185
186 static inline GLuint
187 __glDrawElementsIndirect_maxindex(GLenum type, const GLvoid *indirect) {
188     OS::DebugMessage("warning: %s: unsupported\n", __FUNCTION__);
189     return 0;
190 }
191
192 static inline GLuint
193 __glMultiDrawArrays_maxindex(const GLint *first, const GLsizei *count, GLsizei primcount) {
194     OS::DebugMessage("warning: %s: unsupported\n", __FUNCTION__);
195     return 0;
196 }
197
198 static inline GLuint
199 __glMultiDrawElements_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
200     OS::DebugMessage("warning: %s: unsupported\n", __FUNCTION__);
201     return 0;
202 }
203
204 static inline GLuint
205 __glMultiDrawElementsBaseVertex_maxindex(const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, const GLint * basevertex) {
206     OS::DebugMessage("warning: %s: unsupported\n", __FUNCTION__);
207     return 0;
208 }
209
210 #define __glMultiDrawArraysEXT_maxindex __glMultiDrawArrays_maxindex
211 #define __glMultiDrawElementsEXT_maxindex __glMultiDrawElements_maxindex
212
213 #define __glMultiModeDrawArraysIBM_maxindex(first, count, primcount, modestride) __glMultiDrawArrays_maxindex(first, count, primcount)
214 #define __glMultiModeDrawElementsIBM_maxindex(count, type, indices, primcount, modestride) __glMultiDrawElements_maxindex(count, type, (const GLvoid **)indices, primcount)
215
216
217 static inline size_t
218 __glCallLists_size(GLsizei n, GLenum type)
219 {
220     return n*__gl_type_size(type);
221 }
222
223 #define __glFogfv_size __gl_param_size
224 #define __glFogiv_size __gl_param_size
225
226 #define __glLightfv_size __gl_param_size
227 #define __glLightiv_size __gl_param_size
228
229 #define __glLightModelfv_size __gl_param_size
230 #define __glLightModeliv_size __glLightModelfv_size
231
232 #define __glMaterialfv_size __gl_param_size
233 #define __glMaterialiv_size __glMaterialfv_size
234
235
236 static inline size_t
237 __glMap1d_size(GLenum pname)
238 {
239     switch (pname) {
240     case GL_MAP1_INDEX:
241     case GL_MAP1_TEXTURE_COORD_1:
242         return 1;
243     case GL_MAP1_TEXTURE_COORD_2:
244         return 2;
245     case GL_MAP1_NORMAL:
246     case GL_MAP1_TEXTURE_COORD_3:
247     case GL_MAP1_VERTEX_3:
248         return 3;
249     case GL_MAP1_COLOR_4:
250     case GL_MAP1_TEXTURE_COORD_4:
251     case GL_MAP1_VERTEX_4:
252         return 4;
253     default:
254         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);
255         return 1;
256     }
257 }
258
259 #define __glMap1f_size __glMap1d_size
260
261 static inline size_t
262 __glMap2d_size(GLenum pname)
263 {
264     switch (pname) {
265     case GL_MAP2_INDEX:
266     case GL_MAP2_TEXTURE_COORD_1:
267         return 1;
268     case GL_MAP2_TEXTURE_COORD_2:
269         return 2;
270     case GL_MAP2_NORMAL:
271     case GL_MAP2_TEXTURE_COORD_3:
272     case GL_MAP2_VERTEX_3:
273         return 3;
274     case GL_MAP2_COLOR_4:
275     case GL_MAP2_TEXTURE_COORD_4:
276     case GL_MAP2_VERTEX_4:
277         return 4;
278     default:
279         OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);
280         return 1;
281     }
282 }
283
284 #define __glMap2f_size __glMap2d_size
285
286 #define __glGetBooleanv_size __gl_param_size
287 #define __glGetDoublev_size __glGetBooleanv_size
288 #define __glGetFloatv_size __glGetBooleanv_size
289 #define __glGetIntegerv_size __glGetBooleanv_size
290 #define __glGetInteger64v_size __glGetBooleanv_size
291
292 #define __glGetLightfv_size __glLightfv_size
293 #define __glGetLightiv_size __glLightfv_size
294
295 #define __glGetMaterialfv_size __glMaterialfv_size
296 #define __glGetMaterialiv_size __glMaterialfv_size
297
298
299 #define __glColorTableParameterfv_size __gl_param_size
300 #define __glColorTableParameteriv_size __gl_param_size
301 #define __glGetColorTableParameterfv_size __gl_param_size
302 #define __glGetColorTableParameteriv_size __gl_param_size
303
304 #define __glConvolutionParameterfv_size __gl_param_size
305 #define __glConvolutionParameteriv_size __gl_param_size
306 #define __glGetConvolutionParameterfv_size __gl_param_size
307 #define __glGetConvolutionParameteriv_size __gl_param_size
308
309 #define __glGetHistogramParameterfv_size __gl_param_size
310 #define __glGetHistogramParameteriv_size __gl_param_size
311
312 #define __glGetMinmaxParameterfv_size __gl_param_size
313 #define __glGetMinmaxParameteriv_size __gl_param_size
314
315 #define __glGetProgramivARB_size __gl_param_size
316 #define __glGetProgramivNV_size __gl_param_size
317
318 #define __glGetVertexAttribdvARB_size __gl_param_size
319 #define __glGetVertexAttribfvARB_size __gl_param_size
320 #define __glGetVertexAttribivARB_size __gl_param_size
321 #define __glGetVertexAttribdvNV_size __gl_param_size
322 #define __glGetVertexAttribfvNV_size __gl_param_size
323 #define __glGetVertexAttribivNV_size __gl_param_size
324
325 #define __glGetQueryObjectivARB_size __gl_param_size
326 #define __glGetQueryObjectuivARB_size __glGetQueryObjectivARB_size
327 #define __glGetQueryivARB_size __gl_param_size
328
329 #define __glPointParameterfv_size __glPointParameterfvEXT_size
330 #define __glPointParameteriv_size __glPointParameterfvEXT_size
331 #define __glPointParameterfvARB_size __glPointParameterfvEXT_size
332 #define __glPointParameterfvEXT_size __gl_param_size
333 #define __glPointParameterivNV_size __glPointParameterfvEXT_size
334
335 #define __glGetFramebufferAttachmentParameteriv_size __gl_param_size
336 #define __glGetFramebufferAttachmentParameterivEXT_size __gl_param_size
337
338 static inline size_t
339 __gl_format_channels(GLenum format) {
340     switch (format) {
341     case GL_COLOR_INDEX:
342     case GL_RED:
343     case GL_GREEN:
344     case GL_BLUE:
345     case GL_ALPHA:
346     case GL_INTENSITY:
347     case GL_LUMINANCE:
348     case GL_DEPTH_COMPONENT:
349     case GL_STENCIL_INDEX:
350         return 1;
351     case GL_DEPTH_STENCIL:
352     case GL_LUMINANCE_ALPHA:
353     case GL_RG:
354         return 2;
355     case GL_RGB:
356     case GL_BGR:
357         return 3;
358     case GL_RGBA:
359     case GL_BGRA:
360         return 4;
361     default:
362         OS::DebugMessage("warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format);
363         return 0;
364     }
365 }
366
367 template<class X>
368 static inline bool
369 _is_pot(X x) {
370     return (x & (x - 1)) == 0;
371 }
372
373 template<class X, class Y>
374 static inline X
375 _align(X x, Y y) {
376     return (x + (y - 1)) & (y - 1);
377 }
378
379 static inline size_t
380 __gl_image_size(GLenum format, GLenum type, GLsizei width, GLsizei height, GLsizei depth) {
381     size_t num_channels = __gl_format_channels(format);
382
383     size_t bits_per_pixel;
384     switch (type) {
385     case GL_BITMAP:
386         bits_per_pixel = 1;
387         break;
388     case GL_BYTE:
389     case GL_UNSIGNED_BYTE:
390         bits_per_pixel = 8 * num_channels;
391         break;
392     case GL_SHORT:
393     case GL_UNSIGNED_SHORT:
394     case GL_HALF_FLOAT:
395         bits_per_pixel = 16 * num_channels;
396         break;
397     case GL_INT:
398     case GL_UNSIGNED_INT:
399     case GL_FLOAT:
400         bits_per_pixel = 32 * num_channels;
401         break;
402     case GL_UNSIGNED_BYTE_3_3_2:
403     case GL_UNSIGNED_BYTE_2_3_3_REV:
404         bits_per_pixel = 8;
405         break;
406     case GL_UNSIGNED_SHORT_4_4_4_4:
407     case GL_UNSIGNED_SHORT_4_4_4_4_REV:
408     case GL_UNSIGNED_SHORT_5_5_5_1:
409     case GL_UNSIGNED_SHORT_1_5_5_5_REV:
410     case GL_UNSIGNED_SHORT_5_6_5:
411     case GL_UNSIGNED_SHORT_5_6_5_REV:
412     case GL_UNSIGNED_SHORT_8_8_MESA:
413     case GL_UNSIGNED_SHORT_8_8_REV_MESA:
414         bits_per_pixel = 16;
415         break;
416     case GL_UNSIGNED_INT_8_8_8_8:
417     case GL_UNSIGNED_INT_8_8_8_8_REV:
418     case GL_UNSIGNED_INT_10_10_10_2:
419     case GL_UNSIGNED_INT_2_10_10_10_REV:
420     case GL_UNSIGNED_INT_24_8:
421     case GL_UNSIGNED_INT_10F_11F_11F_REV:
422     case GL_UNSIGNED_INT_5_9_9_9_REV:
423     case GL_UNSIGNED_INT_S8_S8_8_8_NV:
424     case GL_UNSIGNED_INT_8_8_S8_S8_REV_NV:
425         bits_per_pixel = 32;
426         break;
427     case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
428         bits_per_pixel = 64;
429         break;
430     default:
431         OS::DebugMessage("warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type);
432         bits_per_pixel = 0;
433         break;
434     }
435
436     GLint alignment = 4;
437     GLint row_length = 0;
438     GLint image_height = 0;
439     GLint skip_rows = 0;
440     GLint skip_pixels = 0;
441     GLint skip_images = 0;
442
443     __glGetIntegerv(GL_UNPACK_ALIGNMENT,    &alignment);
444     __glGetIntegerv(GL_UNPACK_ROW_LENGTH,   &row_length);
445     __glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &image_height);
446     __glGetIntegerv(GL_UNPACK_SKIP_ROWS,    &skip_rows);
447     __glGetIntegerv(GL_UNPACK_SKIP_PIXELS,  &skip_pixels);
448     __glGetIntegerv(GL_UNPACK_SKIP_IMAGES,  &skip_images);
449
450     if (row_length <= 0) {
451         row_length = width;
452     }
453
454     size_t row_stride = (row_length*bits_per_pixel + 7)/8;
455
456     if (bits_per_pixel < alignment*8 &&
457         (bits_per_pixel & 7) == 0 &&
458         _is_pot(bits_per_pixel)) {
459         row_stride = _align(row_stride, alignment);
460     }
461
462     if (image_height <= 0) {
463         image_height = height;
464     }
465
466     /* XXX: GL_UNPACK_IMAGE_HEIGHT and GL_UNPACK_SKIP_IMAGES should probably
467      * not be considered for pixel rectangles. */
468
469     size_t image_stride = image_height*row_stride;
470
471     size_t size = depth*image_stride;
472
473     size += (skip_pixels*bits_per_pixel + 7)/8;
474     size += skip_rows*row_stride;
475     size += skip_images*image_stride;
476
477     return size;
478 }
479
480 #define __glTexParameterfv_size __gl_param_size
481 #define __glTexParameteriv_size __gl_param_size
482 #define __glGetTexParameterfv_size __gl_param_size
483 #define __glGetTexParameteriv_size __gl_param_size
484 #define __glGetTexLevelParameterfv_size __gl_param_size
485 #define __glGetTexLevelParameteriv_size __gl_param_size
486
487 #define __glTexEnvfv_size __gl_param_size
488 #define __glTexEnviv_size __gl_param_size
489 #define __glGetTexEnvfv_size __gl_param_size
490 #define __glGetTexEnviv_size __gl_param_size
491
492 #define __glTexGendv_size __gl_param_size
493 #define __glTexGenfv_size __gl_param_size
494 #define __glTexGeniv_size __gl_param_size
495 #define __glGetTexGendv_size __gl_param_size
496 #define __glGetTexGenfv_size __gl_param_size
497 #define __glGetTexGeniv_size __gl_param_size
498
499 #define __glTexImage3D_size(format, type, width, height, depth) __gl_image_size(format, type, width, height, depth)
500 #define __glTexImage2D_size(format, type, width, height)        __gl_image_size(format, type, width, height, 1)
501 #define __glTexImage1D_size(format, type, width)                __gl_image_size(format, type, width, 1, 1)
502
503 #define __glTexSubImage3D_size(format, type, width, height, depth) __glTexImage3D_size(format, type, width, height, depth)
504 #define __glTexSubImage2D_size(format, type, width, height)        __glTexImage2D_size(format, type, width, height)
505 #define __glTexSubImage1D_size(format, type, width)                __glTexImage1D_size(format, type, width)
506
507 #define __glTexImage3DEXT_size __glTexImage3D_size
508 #define __glTexImage2DEXT_size __glTexImage2D_size
509 #define __glTexImage1DEXT_size __glTexImage1D_size
510 #define __glTexSubImage3DEXT_size __glTexSubImage3D_size
511 #define __glTexSubImage2DEXT_size __glTexSubImage2D_size
512 #define __glTexSubImage1DEXT_size __glTexSubImage1D_size
513
514 #define __glTextureImage3DEXT_size __glTexImage3D_size
515 #define __glTextureImage2DEXT_size __glTexImage2D_size
516 #define __glTextureImage1DEXT_size __glTexImage1D_size
517 #define __glTextureSubImage3DEXT_size __glTexSubImage3D_size
518 #define __glTextureSubImage2DEXT_size __glTexSubImage2D_size
519 #define __glTextureSubImage1DEXT_size __glTexSubImage1D_size
520
521 #define __glMultiTexImage3DEXT_size __glTexImage3D_size
522 #define __glMultiTexImage2DEXT_size __glTexImage2D_size
523 #define __glMultiTexImage1DEXT_size __glTexImage1D_size
524 #define __glMultiTexSubImage3DEXT_size __glTexSubImage3D_size
525 #define __glMultiTexSubImage2DEXT_size __glTexSubImage2D_size
526 #define __glMultiTexSubImage1DEXT_size __glTexSubImage1D_size
527
528 #define __glDrawPixels_size(format, type, width, height) __glTexImage2D_size(format, type, width, height)
529
530 #define __glBitmap_size(width, height) __glTexImage2D_size(GL_COLOR_INDEX, GL_BITMAP, width, height)
531 #define __glPolygonStipple_size() __glBitmap_size(32, 32)
532
533
534 /* 
535  * 0 terminated integer/float attribute list.
536  */
537 template<class T>
538 static inline size_t
539 __AttribList_size(const T *pAttribList)
540 {
541     size_t size = 0;
542
543     if (pAttribList) {
544         do {
545             ++size;
546         } while (*pAttribList++);
547     }
548
549     return size;
550 }
551
552
553 #endif /* _GL_SIZE_HPP_ */