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@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
__indirect_glGetCompressedTexImage(GLenum target,GLint level,GLvoid * img)43 __indirect_glGetCompressedTexImage(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
CompressedTexImage1D2D(GLenum target,GLint level,GLenum internal_format,GLsizei width,GLsizei height,GLint border,GLsizei image_size,const GLvoid * data,CARD32 rop)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
CompressedTexSubImage1D2D(GLenum target,GLint level,GLsizei xoffset,GLsizei yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei image_size,const GLvoid * data,CARD32 rop)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
__indirect_glCompressedTexImage1D(GLenum target,GLint level,GLenum internal_format,GLsizei width,GLint border,GLsizei image_size,const GLvoid * data)194 __indirect_glCompressedTexImage1D(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
__indirect_glCompressedTexImage2D(GLenum target,GLint level,GLenum internal_format,GLsizei width,GLsizei height,GLint border,GLsizei image_size,const GLvoid * data)206 __indirect_glCompressedTexImage2D(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
__indirect_glCompressedTexImage3D(GLenum target,GLint level,GLenum internal_format,GLsizei width,GLsizei height,GLsizei depth,GLint border,GLsizei image_size,const GLvoid * data)219 __indirect_glCompressedTexImage3D(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
__indirect_glCompressedTexSubImage1D(GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei image_size,const GLvoid * data)267 __indirect_glCompressedTexSubImage1D(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
__indirect_glCompressedTexSubImage2D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLsizei width,GLsizei height,GLenum format,GLsizei image_size,const GLvoid * data)280 __indirect_glCompressedTexSubImage2D(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
__indirect_glCompressedTexSubImage3D(GLenum target,GLint level,GLint xoffset,GLint yoffset,GLint zoffset,GLsizei width,GLsizei height,GLsizei depth,GLenum format,GLsizei image_size,const GLvoid * data)293 __indirect_glCompressedTexSubImage3D(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