1 /* 2 * (C) Copyright IBM Corporation 2004 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * on the rights to use, copy, modify, merge, publish, distribute, sub 9 * license, and/or sell copies of the Software, and to permit persons to whom 10 * the Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 19 * THE COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, 20 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 21 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 22 * USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 /** 26 * \file glx_texture_compression.c 27 * Contains the routines required to implement GLX protocol for 28 * ARB_texture_compression and related extensions. 29 * 30 * \sa http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_compression.txt 31 * 32 * \author Ian Romanick <idr (at) us.ibm.com> 33 */ 34 35 #include "packrender.h" 36 #include "packsingle.h" 37 #include "indirect.h" 38 39 #include <assert.h> 40 41 42 void 43 __indirect_glGetCompressedTexImageARB(GLenum target, GLint level, 44 GLvoid * img) 45 { 46 __GLX_SINGLE_DECLARE_VARIABLES(); 47 xGLXGetTexImageReply reply; 48 size_t image_bytes; 49 50 __GLX_SINGLE_LOAD_VARIABLES(); 51 __GLX_SINGLE_BEGIN(X_GLsop_GetCompressedTexImage, 8); 52 __GLX_SINGLE_PUT_LONG(0, target); 53 __GLX_SINGLE_PUT_LONG(4, level); 54 __GLX_SINGLE_READ_XREPLY(); 55 56 image_bytes = reply.width; 57 assert(image_bytes <= ((4 * reply.length) - 0)); 58 assert(image_bytes >= ((4 * reply.length) - 3)); 59 60 if (image_bytes != 0) { 61 _XRead(dpy, (char *) img, image_bytes); 62 if (image_bytes < (4 * reply.length)) { 63 _XEatData(dpy, (4 * reply.length) - image_bytes); 64 } 65 } 66 67 __GLX_SINGLE_END(); 68 } 69 70 71 /** 72 * Internal function used for \c glCompressedTexImage1D and 73 * \c glCompressedTexImage2D. 74 */ 75 static void 76 CompressedTexImage1D2D(GLenum target, GLint level, 77 GLenum internal_format, 78 GLsizei width, GLsizei height, 79 GLint border, GLsizei image_size, 80 const GLvoid * data, CARD32 rop) 81 { 82 __GLX_DECLARE_VARIABLES(); 83 84 __GLX_LOAD_VARIABLES(); 85 if (gc->currentDpy == NULL) { 86 return; 87 } 88 89 if ((target == GL_PROXY_TEXTURE_1D) 90 || (target == GL_PROXY_TEXTURE_2D) 91 || (target == GL_PROXY_TEXTURE_CUBE_MAP)) { 92 compsize = 0; 93 } 94 else { 95 compsize = image_size; 96 } 97 98 cmdlen = __GLX_PAD(__GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE + compsize); 99 if (cmdlen <= gc->maxSmallRenderCommandSize) { 100 __GLX_BEGIN_VARIABLE(rop, cmdlen); 101 __GLX_PUT_LONG(4, target); 102 __GLX_PUT_LONG(8, level); 103 __GLX_PUT_LONG(12, internal_format); 104 __GLX_PUT_LONG(16, width); 105 __GLX_PUT_LONG(20, height); 106 __GLX_PUT_LONG(24, border); 107 __GLX_PUT_LONG(28, image_size); 108 if (compsize != 0) { 109 __GLX_PUT_CHAR_ARRAY(__GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE, 110 data, image_size); 111 } 112 __GLX_END(cmdlen); 113 } 114 else { 115 assert(compsize != 0); 116 117 __GLX_BEGIN_VARIABLE_LARGE(rop, cmdlen + 4); 118 __GLX_PUT_LONG(8, target); 119 __GLX_PUT_LONG(12, level); 120 __GLX_PUT_LONG(16, internal_format); 121 __GLX_PUT_LONG(20, width); 122 __GLX_PUT_LONG(24, height); 123 __GLX_PUT_LONG(28, border); 124 __GLX_PUT_LONG(32, image_size); 125 __glXSendLargeCommand(gc, gc->pc, 126 __GLX_COMPRESSED_TEXIMAGE_CMD_HDR_SIZE + 4, 127 data, image_size); 128 } 129 } 130 131 132 /** 133 * Internal function used for \c glCompressedTexSubImage1D and 134 * \c glCompressedTexSubImage2D. 135 */ 136 static void 137 CompressedTexSubImage1D2D(GLenum target, GLint level, 138 GLsizei xoffset, GLsizei yoffset, 139 GLsizei width, GLsizei height, 140 GLenum format, GLsizei image_size, 141 const GLvoid * data, CARD32 rop) 142 { 143 __GLX_DECLARE_VARIABLES(); 144 145 __GLX_LOAD_VARIABLES(); 146 if (gc->currentDpy == NULL) { 147 return; 148 } 149 150 if (target == GL_PROXY_TEXTURE_3D) { 151 compsize = 0; 152 } 153 else { 154 compsize = image_size; 155 } 156 157 cmdlen = __GLX_PAD(__GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE + compsize); 158 if (cmdlen <= gc->maxSmallRenderCommandSize) { 159 __GLX_BEGIN_VARIABLE(rop, cmdlen); 160 __GLX_PUT_LONG(4, target); 161 __GLX_PUT_LONG(8, level); 162 __GLX_PUT_LONG(12, xoffset); 163 __GLX_PUT_LONG(16, yoffset); 164 __GLX_PUT_LONG(20, width); 165 __GLX_PUT_LONG(24, height); 166 __GLX_PUT_LONG(28, format); 167 __GLX_PUT_LONG(32, image_size); 168 if (compsize != 0) { 169 __GLX_PUT_CHAR_ARRAY(__GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE, 170 data, image_size); 171 } 172 __GLX_END(cmdlen); 173 } 174 else { 175 assert(compsize != 0); 176 177 __GLX_BEGIN_VARIABLE_LARGE(rop, cmdlen + 4); 178 __GLX_PUT_LONG(8, target); 179 __GLX_PUT_LONG(12, level); 180 __GLX_PUT_LONG(16, xoffset); 181 __GLX_PUT_LONG(20, yoffset); 182 __GLX_PUT_LONG(24, width); 183 __GLX_PUT_LONG(28, height); 184 __GLX_PUT_LONG(32, format); 185 __GLX_PUT_LONG(36, image_size); 186 __glXSendLargeCommand(gc, gc->pc, 187 __GLX_COMPRESSED_TEXSUBIMAGE_CMD_HDR_SIZE + 4, 188 data, image_size); 189 } 190 } 191 192 193 void 194 __indirect_glCompressedTexImage1DARB(GLenum target, GLint level, 195 GLenum internal_format, GLsizei width, 196 GLint border, GLsizei image_size, 197 const GLvoid * data) 198 { 199 CompressedTexImage1D2D(target, level, internal_format, width, 0, 200 border, image_size, data, 201 X_GLrop_CompressedTexImage1D); 202 } 203 204 205 void 206 __indirect_glCompressedTexImage2DARB(GLenum target, GLint level, 207 GLenum internal_format, 208 GLsizei width, GLsizei height, 209 GLint border, GLsizei image_size, 210 const GLvoid * data) 211 { 212 CompressedTexImage1D2D(target, level, internal_format, width, height, 213 border, image_size, data, 214 X_GLrop_CompressedTexImage2D); 215 } 216 217 218 void 219 __indirect_glCompressedTexImage3DARB(GLenum target, GLint level, 220 GLenum internal_format, 221 GLsizei width, GLsizei height, 222 GLsizei depth, GLint border, 223 GLsizei image_size, const GLvoid * data) 224 { 225 __GLX_DECLARE_VARIABLES(); 226 227 __GLX_LOAD_VARIABLES(); 228 if (gc->currentDpy == NULL) { 229 return; 230 } 231 232 cmdlen = __GLX_PAD(__GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE + image_size); 233 if (cmdlen <= gc->maxSmallRenderCommandSize) { 234 __GLX_BEGIN_VARIABLE(X_GLrop_CompressedTexImage3D, cmdlen); 235 __GLX_PUT_LONG(4, target); 236 __GLX_PUT_LONG(8, level); 237 __GLX_PUT_LONG(12, internal_format); 238 __GLX_PUT_LONG(16, width); 239 __GLX_PUT_LONG(20, height); 240 __GLX_PUT_LONG(24, depth); 241 __GLX_PUT_LONG(28, border); 242 __GLX_PUT_LONG(32, image_size); 243 if (image_size != 0) { 244 __GLX_PUT_CHAR_ARRAY(__GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE, 245 data, image_size); 246 } 247 __GLX_END(cmdlen); 248 } 249 else { 250 __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_CompressedTexImage3D, cmdlen + 4); 251 __GLX_PUT_LONG(8, target); 252 __GLX_PUT_LONG(12, level); 253 __GLX_PUT_LONG(16, internal_format); 254 __GLX_PUT_LONG(20, width); 255 __GLX_PUT_LONG(24, height); 256 __GLX_PUT_LONG(28, depth); 257 __GLX_PUT_LONG(32, border); 258 __GLX_PUT_LONG(36, image_size); 259 __glXSendLargeCommand(gc, gc->pc, 260 __GLX_COMPRESSED_TEXIMAGE_3D_CMD_HDR_SIZE + 4, 261 data, image_size); 262 } 263 } 264 265 266 void 267 __indirect_glCompressedTexSubImage1DARB(GLenum target, GLint level, 268 GLint xoffset, 269 GLsizei width, 270 GLenum format, GLsizei image_size, 271 const GLvoid * data) 272 { 273 CompressedTexSubImage1D2D(target, level, xoffset, 0, width, 0, 274 format, image_size, data, 275 X_GLrop_CompressedTexSubImage1D); 276 } 277 278 279 void 280 __indirect_glCompressedTexSubImage2DARB(GLenum target, GLint level, 281 GLint xoffset, GLint yoffset, 282 GLsizei width, GLsizei height, 283 GLenum format, GLsizei image_size, 284 const GLvoid * data) 285 { 286 CompressedTexSubImage1D2D(target, level, xoffset, yoffset, width, height, 287 format, image_size, data, 288 X_GLrop_CompressedTexSubImage2D); 289 } 290 291 292 void 293 __indirect_glCompressedTexSubImage3DARB(GLenum target, GLint level, 294 GLint xoffset, GLint yoffset, 295 GLint zoffset, GLsizei width, 296 GLsizei height, GLsizei depth, 297 GLenum format, GLsizei image_size, 298 const GLvoid * data) 299 { 300 __GLX_DECLARE_VARIABLES(); 301 302 __GLX_LOAD_VARIABLES(); 303 if (gc->currentDpy == NULL) { 304 return; 305 } 306 307 cmdlen = __GLX_PAD(__GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE 308 + image_size); 309 if (cmdlen <= gc->maxSmallRenderCommandSize) { 310 __GLX_BEGIN_VARIABLE(X_GLrop_CompressedTexSubImage3D, cmdlen); 311 __GLX_PUT_LONG(4, target); 312 __GLX_PUT_LONG(8, level); 313 __GLX_PUT_LONG(12, xoffset); 314 __GLX_PUT_LONG(16, yoffset); 315 __GLX_PUT_LONG(20, zoffset); 316 __GLX_PUT_LONG(24, width); 317 __GLX_PUT_LONG(28, height); 318 __GLX_PUT_LONG(32, depth); 319 __GLX_PUT_LONG(36, format); 320 __GLX_PUT_LONG(40, image_size); 321 if (image_size != 0) { 322 __GLX_PUT_CHAR_ARRAY(__GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE, 323 data, image_size); 324 } 325 __GLX_END(cmdlen); 326 } 327 else { 328 __GLX_BEGIN_VARIABLE_LARGE(X_GLrop_CompressedTexSubImage3D, cmdlen + 4); 329 __GLX_PUT_LONG(8, target); 330 __GLX_PUT_LONG(12, level); 331 __GLX_PUT_LONG(16, xoffset); 332 __GLX_PUT_LONG(20, yoffset); 333 __GLX_PUT_LONG(24, zoffset); 334 __GLX_PUT_LONG(28, width); 335 __GLX_PUT_LONG(32, height); 336 __GLX_PUT_LONG(36, depth); 337 __GLX_PUT_LONG(40, format); 338 __GLX_PUT_LONG(44, image_size); 339 __glXSendLargeCommand(gc, gc->pc, 340 __GLX_COMPRESSED_TEXSUBIMAGE_3D_CMD_HDR_SIZE + 4, 341 data, image_size); 342 } 343 } 344
