projects / mesa.git / blob
? search:


7bbdebb3aa4fd4ca17ea85fd82d914c17590e97e
[mesa.git] / src / mesa / main / format_unpack.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (c) 2011 VMware, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
20 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24
25 #include "colormac.h"
26 #include "format_unpack.h"
27 #include "macros.h"
28 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
29 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
30
31
32 /** Helper struct for MESA_FORMAT_Z32_FLOAT_X24S8 */
33 struct z32f_x24s8
34 {
35 float z;
36 uint32_t x24s8;
37 };
38
39
40 /* Expand 1, 2, 3, 4, 5, 6-bit values to fill 8 bits */
41
42 #define EXPAND_1_8(X) ( (X) ? 0xff : 0x0 )
43
44 #define EXPAND_2_8(X) ( ((X) << 6) | ((X) << 4) | ((X) << 2) | (X) )
45
46 #define EXPAND_3_8(X) ( ((X) << 5) | ((X) << 2) | ((X) >> 1) )
47
48 #define EXPAND_4_8(X) ( ((X) << 4) | (X) )
49
50 #define EXPAND_5_8(X) ( ((X) << 3) | ((X) >> 2) )
51
52 #define EXPAND_6_8(X) ( ((X) << 2) | ((X) >> 4) )
53
54
55 /**
56 * Convert an 8-bit sRGB value from non-linear space to a
57 * linear RGB value in [0, 1].
58 * Implemented with a 256-entry lookup table.
59 */
60 static inline GLfloat
61 nonlinear_to_linear(GLubyte cs8)
62 {
63 static GLfloat table[256];
64 static GLboolean tableReady = GL_FALSE;
65 if (!tableReady) {
66 /* compute lookup table now */
67 GLuint i;
68 for (i = 0; i < 256; i++) {
69 const GLfloat cs = UBYTE_TO_FLOAT(i);
70 if (cs <= 0.04045) {
71 table[i] = cs / 12.92f;
72 }
73 else {
74 table[i] = (GLfloat) pow((cs + 0.055) / 1.055, 2.4);
75 }
76 }
77 tableReady = GL_TRUE;
78 }
79 return table[cs8];
80 }
81
82
83 /**********************************************************************/
84 /* Unpack, returning GLfloat colors */
85 /**********************************************************************/
86
87 typedef void (*unpack_rgba_func)(const void *src, GLfloat dst[][4], GLuint n);
88
89
90 static void
91 unpack_RGBA8888(const void *src, GLfloat dst[][4], GLuint n)
92 {
93 const GLuint *s = ((const GLuint *) src);
94 GLuint i;
95 for (i = 0; i < n; i++) {
96 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) );
97 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
98 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
99 dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff );
100 }
101 }
102
103 static void
104 unpack_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n)
105 {
106 const GLuint *s = ((const GLuint *) src);
107 GLuint i;
108 for (i = 0; i < n; i++) {
109 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff );
110 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
111 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
112 dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) );
113 }
114 }
115
116 static void
117 unpack_ARGB8888(const void *src, GLfloat dst[][4], GLuint n)
118 {
119 const GLuint *s = ((const GLuint *) src);
120 GLuint i;
121 for (i = 0; i < n; i++) {
122 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
123 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
124 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff );
125 dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) );
126 }
127 }
128
129 static void
130 unpack_ARGB8888_REV(const void *src, GLfloat dst[][4], GLuint n)
131 {
132 const GLuint *s = ((const GLuint *) src);
133 GLuint i;
134 for (i = 0; i < n; i++) {
135 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
136 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
137 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) );
138 dst[i][ACOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff );
139 }
140 }
141
142 static void
143 unpack_RGBX8888(const void *src, GLfloat dst[][4], GLuint n)
144 {
145 const GLuint *s = ((const GLuint *) src);
146 GLuint i;
147 for (i = 0; i < n; i++) {
148 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) );
149 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
150 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
151 dst[i][ACOMP] = 1.0f;
152 }
153 }
154
155 static void
156 unpack_RGBX8888_REV(const void *src, GLfloat dst[][4], GLuint n)
157 {
158 const GLuint *s = ((const GLuint *) src);
159 GLuint i;
160 for (i = 0; i < n; i++) {
161 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff );
162 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
163 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
164 dst[i][ACOMP] = 1.0f;
165 }
166 }
167
168 static void
169 unpack_XRGB8888(const void *src, GLfloat dst[][4], GLuint n)
170 {
171 const GLuint *s = ((const GLuint *) src);
172 GLuint i;
173 for (i = 0; i < n; i++) {
174 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
175 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
176 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] ) & 0xff );
177 dst[i][ACOMP] = 1.0f;
178 }
179 }
180
181 static void
182 unpack_XRGB8888_REV(const void *src, GLfloat dst[][4], GLuint n)
183 {
184 const GLuint *s = ((const GLuint *) src);
185 GLuint i;
186 for (i = 0; i < n; i++) {
187 dst[i][RCOMP] = UBYTE_TO_FLOAT( (s[i] >> 8) & 0xff );
188 dst[i][GCOMP] = UBYTE_TO_FLOAT( (s[i] >> 16) & 0xff );
189 dst[i][BCOMP] = UBYTE_TO_FLOAT( (s[i] >> 24) );
190 dst[i][ACOMP] = 1.0f;
191 }
192 }
193
194 static void
195 unpack_RGB888(const void *src, GLfloat dst[][4], GLuint n)
196 {
197 const GLubyte *s = (const GLubyte *) src;
198 GLuint i;
199 for (i = 0; i < n; i++) {
200 dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i*3+2] );
201 dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i*3+1] );
202 dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i*3+0] );
203 dst[i][ACOMP] = 1.0F;
204 }
205 }
206
207 static void
208 unpack_BGR888(const void *src, GLfloat dst[][4], GLuint n)
209 {
210 const GLubyte *s = (const GLubyte *) src;
211 GLuint i;
212 for (i = 0; i < n; i++) {
213 dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i*3+0] );
214 dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i*3+1] );
215 dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i*3+2] );
216 dst[i][ACOMP] = 1.0F;
217 }
218 }
219
220 static void
221 unpack_RGB565(const void *src, GLfloat dst[][4], GLuint n)
222 {
223 const GLushort *s = ((const GLushort *) src);
224 GLuint i;
225 for (i = 0; i < n; i++) {
226 dst[i][RCOMP] = ((s[i] >> 11) & 0x1f) * (1.0F / 31.0F);
227 dst[i][GCOMP] = ((s[i] >> 5 ) & 0x3f) * (1.0F / 63.0F);
228 dst[i][BCOMP] = ((s[i] ) & 0x1f) * (1.0F / 31.0F);
229 dst[i][ACOMP] = 1.0F;
230 }
231 }
232
233 static void
234 unpack_RGB565_REV(const void *src, GLfloat dst[][4], GLuint n)
235 {
236 const GLushort *s = ((const GLushort *) src);
237 GLuint i;
238 for (i = 0; i < n; i++) {
239 GLuint t = (s[i] >> 8) | (s[i] << 8); /* byte swap */
240 dst[i][RCOMP] = UBYTE_TO_FLOAT( ((t >> 8) & 0xf8) | ((t >> 13) & 0x7) );
241 dst[i][GCOMP] = UBYTE_TO_FLOAT( ((t >> 3) & 0xfc) | ((t >> 9) & 0x3) );
242 dst[i][BCOMP] = UBYTE_TO_FLOAT( ((t << 3) & 0xf8) | ((t >> 2) & 0x7) );
243 dst[i][ACOMP] = 1.0F;
244 }
245 }
246
247 static void
248 unpack_ARGB4444(const void *src, GLfloat dst[][4], GLuint n)
249 {
250 const GLushort *s = ((const GLushort *) src);
251 GLuint i;
252 for (i = 0; i < n; i++) {
253 dst[i][RCOMP] = ((s[i] >> 8) & 0xf) * (1.0F / 15.0F);
254 dst[i][GCOMP] = ((s[i] >> 4) & 0xf) * (1.0F / 15.0F);
255 dst[i][BCOMP] = ((s[i] ) & 0xf) * (1.0F / 15.0F);
256 dst[i][ACOMP] = ((s[i] >> 12) & 0xf) * (1.0F / 15.0F);
257 }
258 }
259
260 static void
261 unpack_ARGB4444_REV(const void *src, GLfloat dst[][4], GLuint n)
262 {
263 const GLushort *s = ((const GLushort *) src);
264 GLuint i;
265 for (i = 0; i < n; i++) {
266 dst[i][RCOMP] = ((s[i] ) & 0xf) * (1.0F / 15.0F);
267 dst[i][GCOMP] = ((s[i] >> 12) & 0xf) * (1.0F / 15.0F);
268 dst[i][BCOMP] = ((s[i] >> 8) & 0xf) * (1.0F / 15.0F);
269 dst[i][ACOMP] = ((s[i] >> 4) & 0xf) * (1.0F / 15.0F);
270 }
271 }
272
273 static void
274 unpack_RGBA5551(const void *src, GLfloat dst[][4], GLuint n)
275 {
276 const GLushort *s = ((const GLushort *) src);
277 GLuint i;
278 for (i = 0; i < n; i++) {
279 dst[i][RCOMP] = ((s[i] >> 11) & 0x1f) * (1.0F / 31.0F);
280 dst[i][GCOMP] = ((s[i] >> 6) & 0x1f) * (1.0F / 31.0F);
281 dst[i][BCOMP] = ((s[i] >> 1) & 0x1f) * (1.0F / 31.0F);
282 dst[i][ACOMP] = ((s[i] ) & 0x01) * 1.0F;
283 }
284 }
285
286 static void
287 unpack_ARGB1555(const void *src, GLfloat dst[][4], GLuint n)
288 {
289 const GLushort *s = ((const GLushort *) src);
290 GLuint i;
291 for (i = 0; i < n; i++) {
292 dst[i][RCOMP] = ((s[i] >> 10) & 0x1f) * (1.0F / 31.0F);
293 dst[i][GCOMP] = ((s[i] >> 5) & 0x1f) * (1.0F / 31.0F);
294 dst[i][BCOMP] = ((s[i] >> 0) & 0x1f) * (1.0F / 31.0F);
295 dst[i][ACOMP] = ((s[i] >> 15) & 0x01) * 1.0F;
296 }
297 }
298
299 static void
300 unpack_ARGB1555_REV(const void *src, GLfloat dst[][4], GLuint n)
301 {
302 const GLushort *s = ((const GLushort *) src);
303 GLuint i;
304 for (i = 0; i < n; i++) {
305 GLushort tmp = (s[i] << 8) | (s[i] >> 8); /* byteswap */
306 dst[i][RCOMP] = ((tmp >> 10) & 0x1f) * (1.0F / 31.0F);
307 dst[i][GCOMP] = ((tmp >> 5) & 0x1f) * (1.0F / 31.0F);
308 dst[i][BCOMP] = ((tmp >> 0) & 0x1f) * (1.0F / 31.0F);
309 dst[i][ACOMP] = ((tmp >> 15) & 0x01) * 1.0F;
310 }
311 }
312
313 static void
314 unpack_AL44(const void *src, GLfloat dst[][4], GLuint n)
315 {
316 const GLubyte *s = ((const GLubyte *) src);
317 GLuint i;
318 for (i = 0; i < n; i++) {
319 dst[i][RCOMP] =
320 dst[i][GCOMP] =
321 dst[i][BCOMP] = (s[i] & 0xf) * (1.0F / 15.0F);
322 dst[i][ACOMP] = ((s[i] >> 4) & 0xf) * (1.0F / 15.0F);
323 }
324 }
325
326 static void
327 unpack_AL88(const void *src, GLfloat dst[][4], GLuint n)
328 {
329 const GLushort *s = ((const GLushort *) src);
330 GLuint i;
331 for (i = 0; i < n; i++) {
332 dst[i][RCOMP] =
333 dst[i][GCOMP] =
334 dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i] & 0xff );
335 dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] >> 8 );
336 }
337 }
338
339 static void
340 unpack_AL88_REV(const void *src, GLfloat dst[][4], GLuint n)
341 {
342 const GLushort *s = ((const GLushort *) src);
343 GLuint i;
344 for (i = 0; i < n; i++) {
345 dst[i][RCOMP] =
346 dst[i][GCOMP] =
347 dst[i][BCOMP] = UBYTE_TO_FLOAT( s[i] >> 8 );
348 dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] & 0xff );
349 }
350 }
351
352 static void
353 unpack_AL1616(const void *src, GLfloat dst[][4], GLuint n)
354 {
355 const GLuint *s = ((const GLuint *) src);
356 GLuint i;
357 for (i = 0; i < n; i++) {
358 dst[i][RCOMP] =
359 dst[i][GCOMP] =
360 dst[i][BCOMP] = USHORT_TO_FLOAT( s[i] & 0xffff );
361 dst[i][ACOMP] = USHORT_TO_FLOAT( s[i] >> 16 );
362 }
363 }
364
365 static void
366 unpack_AL1616_REV(const void *src, GLfloat dst[][4], GLuint n)
367 {
368 const GLuint *s = ((const GLuint *) src);
369 GLuint i;
370 for (i = 0; i < n; i++) {
371 dst[i][RCOMP] =
372 dst[i][GCOMP] =
373 dst[i][BCOMP] = USHORT_TO_FLOAT( s[i] >> 16 );
374 dst[i][ACOMP] = USHORT_TO_FLOAT( s[i] & 0xffff );
375 }
376 }
377
378 static void
379 unpack_RGB332(const void *src, GLfloat dst[][4], GLuint n)
380 {
381 const GLubyte *s = ((const GLubyte *) src);
382 GLuint i;
383 for (i = 0; i < n; i++) {
384 dst[i][RCOMP] = ((s[i] >> 5) & 0x7) * (1.0F / 7.0F);
385 dst[i][GCOMP] = ((s[i] >> 2) & 0x7) * (1.0F / 7.0F);
386 dst[i][BCOMP] = ((s[i] ) & 0x3) * (1.0F / 3.0F);
387 dst[i][ACOMP] = 1.0F;
388 }
389 }
390
391
392 static void
393 unpack_A8(const void *src, GLfloat dst[][4], GLuint n)
394 {
395 const GLubyte *s = ((const GLubyte *) src);
396 GLuint i;
397 for (i = 0; i < n; i++) {
398 dst[i][RCOMP] =
399 dst[i][GCOMP] =
400 dst[i][BCOMP] = 0.0F;
401 dst[i][ACOMP] = UBYTE_TO_FLOAT(s[i]);
402 }
403 }
404
405 static void
406 unpack_A16(const void *src, GLfloat dst[][4], GLuint n)
407 {
408 const GLushort *s = ((const GLushort *) src);
409 GLuint i;
410 for (i = 0; i < n; i++) {
411 dst[i][RCOMP] =
412 dst[i][GCOMP] =
413 dst[i][BCOMP] = 0.0F;
414 dst[i][ACOMP] = USHORT_TO_FLOAT(s[i]);
415 }
416 }
417
418 static void
419 unpack_L8(const void *src, GLfloat dst[][4], GLuint n)
420 {
421 const GLubyte *s = ((const GLubyte *) src);
422 GLuint i;
423 for (i = 0; i < n; i++) {
424 dst[i][RCOMP] =
425 dst[i][GCOMP] =
426 dst[i][BCOMP] = UBYTE_TO_FLOAT(s[i]);
427 dst[i][ACOMP] = 1.0F;
428 }
429 }
430
431 static void
432 unpack_L16(const void *src, GLfloat dst[][4], GLuint n)
433 {
434 const GLushort *s = ((const GLushort *) src);
435 GLuint i;
436 for (i = 0; i < n; i++) {
437 dst[i][RCOMP] =
438 dst[i][GCOMP] =
439 dst[i][BCOMP] = USHORT_TO_FLOAT(s[i]);
440 dst[i][ACOMP] = 1.0F;
441 }
442 }
443
444 static void
445 unpack_I8(const void *src, GLfloat dst[][4], GLuint n)
446 {
447 const GLubyte *s = ((const GLubyte *) src);
448 GLuint i;
449 for (i = 0; i < n; i++) {
450 dst[i][RCOMP] =
451 dst[i][GCOMP] =
452 dst[i][BCOMP] =
453 dst[i][ACOMP] = UBYTE_TO_FLOAT(s[i]);
454 }
455 }
456
457 static void
458 unpack_I16(const void *src, GLfloat dst[][4], GLuint n)
459 {
460 const GLushort *s = ((const GLushort *) src);
461 GLuint i;
462 for (i = 0; i < n; i++) {
463 dst[i][RCOMP] =
464 dst[i][GCOMP] =
465 dst[i][BCOMP] =
466 dst[i][ACOMP] = USHORT_TO_FLOAT(s[i]);
467 }
468 }
469
470 static void
471 unpack_YCBCR(const void *src, GLfloat dst[][4], GLuint n)
472 {
473 GLuint i;
474 for (i = 0; i < n; i++) {
475 const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */
476 const GLushort *src1 = src0 + 1; /* odd */
477 const GLubyte y0 = (*src0 >> 8) & 0xff; /* luminance */
478 const GLubyte cb = *src0 & 0xff; /* chroma U */
479 const GLubyte y1 = (*src1 >> 8) & 0xff; /* luminance */
480 const GLubyte cr = *src1 & 0xff; /* chroma V */
481 const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */
482 GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
483 GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
484 GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
485 r *= (1.0F / 255.0F);
486 g *= (1.0F / 255.0F);
487 b *= (1.0F / 255.0F);
488 dst[i][RCOMP] = CLAMP(r, 0.0F, 1.0F);
489 dst[i][GCOMP] = CLAMP(g, 0.0F, 1.0F);
490 dst[i][BCOMP] = CLAMP(b, 0.0F, 1.0F);
491 dst[i][ACOMP] = 1.0F;
492 }
493 }
494
495 static void
496 unpack_YCBCR_REV(const void *src, GLfloat dst[][4], GLuint n)
497 {
498 GLuint i;
499 for (i = 0; i < n; i++) {
500 const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */
501 const GLushort *src1 = src0 + 1; /* odd */
502 const GLubyte y0 = *src0 & 0xff; /* luminance */
503 const GLubyte cr = (*src0 >> 8) & 0xff; /* chroma V */
504 const GLubyte y1 = *src1 & 0xff; /* luminance */
505 const GLubyte cb = (*src1 >> 8) & 0xff; /* chroma U */
506 const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */
507 GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
508 GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
509 GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
510 r *= (1.0F / 255.0F);
511 g *= (1.0F / 255.0F);
512 b *= (1.0F / 255.0F);
513 dst[i][RCOMP] = CLAMP(r, 0.0F, 1.0F);
514 dst[i][GCOMP] = CLAMP(g, 0.0F, 1.0F);
515 dst[i][BCOMP] = CLAMP(b, 0.0F, 1.0F);
516 dst[i][ACOMP] = 1.0F;
517 }
518 }
519
520 static void
521 unpack_R8(const void *src, GLfloat dst[][4], GLuint n)
522 {
523 const GLubyte *s = ((const GLubyte *) src);
524 GLuint i;
525 for (i = 0; i < n; i++) {
526 dst[i][0] = UBYTE_TO_FLOAT(s[i]);
527 dst[i][1] =
528 dst[i][2] = 0.0F;
529 dst[i][3] = 1.0F;
530 }
531 }
532
533 static void
534 unpack_GR88(const void *src, GLfloat dst[][4], GLuint n)
535 {
536 const GLushort *s = ((const GLushort *) src);
537 GLuint i;
538 for (i = 0; i < n; i++) {
539 dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i] & 0xff );
540 dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i] >> 8 );
541 dst[i][BCOMP] = 0.0;
542 dst[i][ACOMP] = 1.0;
543 }
544 }
545
546 static void
547 unpack_RG88(const void *src, GLfloat dst[][4], GLuint n)
548 {
549 const GLushort *s = ((const GLushort *) src);
550 GLuint i;
551 for (i = 0; i < n; i++) {
552 dst[i][RCOMP] = UBYTE_TO_FLOAT( s[i] >> 8 );
553 dst[i][GCOMP] = UBYTE_TO_FLOAT( s[i] & 0xff );
554 dst[i][BCOMP] = 0.0;
555 dst[i][ACOMP] = 1.0;
556 }
557 }
558
559 static void
560 unpack_R16(const void *src, GLfloat dst[][4], GLuint n)
561 {
562 const GLushort *s = ((const GLushort *) src);
563 GLuint i;
564 for (i = 0; i < n; i++) {
565 dst[i][RCOMP] = USHORT_TO_FLOAT(s[i]);
566 dst[i][GCOMP] = 0.0;
567 dst[i][BCOMP] = 0.0;
568 dst[i][ACOMP] = 1.0;
569 }
570 }
571
572 static void
573 unpack_RG1616(const void *src, GLfloat dst[][4], GLuint n)
574 {
575 const GLuint *s = ((const GLuint *) src);
576 GLuint i;
577 for (i = 0; i < n; i++) {
578 dst[i][RCOMP] = USHORT_TO_FLOAT( s[i] & 0xffff );
579 dst[i][GCOMP] = USHORT_TO_FLOAT( s[i] >> 16 );
580 dst[i][BCOMP] = 0.0;
581 dst[i][ACOMP] = 1.0;
582 }
583 }
584
585 static void
586 unpack_RG1616_REV(const void *src, GLfloat dst[][4], GLuint n)
587 {
588 const GLuint *s = ((const GLuint *) src);
589 GLuint i;
590 for (i = 0; i < n; i++) {
591 dst[i][RCOMP] = USHORT_TO_FLOAT( s[i] >> 16 );
592 dst[i][GCOMP] = USHORT_TO_FLOAT( s[i] & 0xffff );
593 dst[i][BCOMP] = 0.0;
594 dst[i][ACOMP] = 1.0;
595 }
596 }
597
598 static void
599 unpack_ARGB2101010(const void *src, GLfloat dst[][4], GLuint n)
600 {
601 const GLuint *s = ((const GLuint *) src);
602 GLuint i;
603 for (i = 0; i < n; i++) {
604 dst[i][RCOMP] = ((s[i] >> 20) & 0x3ff) * (1.0F / 1023.0F);
605 dst[i][GCOMP] = ((s[i] >> 10) & 0x3ff) * (1.0F / 1023.0F);
606 dst[i][BCOMP] = ((s[i] >> 0) & 0x3ff) * (1.0F / 1023.0F);
607 dst[i][ACOMP] = ((s[i] >> 30) & 0x03) * (1.0F / 3.0F);
608 }
609 }
610
611
612 static void
613 unpack_ABGR2101010_UINT(const void *src, GLfloat dst[][4], GLuint n)
614 {
615 const GLuint *s = ((const GLuint *) src);
616 GLuint i;
617 for (i = 0; i < n; i++) {
618 dst[i][RCOMP] = (GLfloat)((s[i] >> 0) & 0x3ff);
619 dst[i][GCOMP] = (GLfloat)((s[i] >> 10) & 0x3ff);
620 dst[i][BCOMP] = (GLfloat)((s[i] >> 20) & 0x3ff);
621 dst[i][ACOMP] = (GLfloat)((s[i] >> 30) & 0x03);
622 }
623 }
624
625
626 static void
627 unpack_Z24_S8(const void *src, GLfloat dst[][4], GLuint n)
628 {
629 /* only return Z, not stencil data */
630 const GLuint *s = ((const GLuint *) src);
631 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
632 GLuint i;
633 for (i = 0; i < n; i++) {
634 dst[i][0] =
635 dst[i][1] =
636 dst[i][2] = (GLfloat) ((s[i] >> 8) * scale);
637 dst[i][3] = 1.0F;
638 ASSERT(dst[i][0] >= 0.0F);
639 ASSERT(dst[i][0] <= 1.0F);
640 }
641 }
642
643 static void
644 unpack_S8_Z24(const void *src, GLfloat dst[][4], GLuint n)
645 {
646 /* only return Z, not stencil data */
647 const GLuint *s = ((const GLuint *) src);
648 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
649 GLuint i;
650 for (i = 0; i < n; i++) {
651 dst[i][0] =
652 dst[i][1] =
653 dst[i][2] = (float) ((s[i] & 0x00ffffff) * scale);
654 dst[i][3] = 1.0F;
655 ASSERT(dst[i][0] >= 0.0F);
656 ASSERT(dst[i][0] <= 1.0F);
657 }
658 }
659
660 static void
661 unpack_Z16(const void *src, GLfloat dst[][4], GLuint n)
662 {
663 const GLushort *s = ((const GLushort *) src);
664 GLuint i;
665 for (i = 0; i < n; i++) {
666 dst[i][0] =
667 dst[i][1] =
668 dst[i][2] = s[i] * (1.0F / 65535.0F);
669 dst[i][3] = 1.0F;
670 }
671 }
672
673 static void
674 unpack_X8_Z24(const void *src, GLfloat dst[][4], GLuint n)
675 {
676 unpack_S8_Z24(src, dst, n);
677 }
678
679 static void
680 unpack_Z24_X8(const void *src, GLfloat dst[][4], GLuint n)
681 {
682 unpack_Z24_S8(src, dst, n);
683 }
684
685 static void
686 unpack_Z32(const void *src, GLfloat dst[][4], GLuint n)
687 {
688 const GLuint *s = ((const GLuint *) src);
689 GLuint i;
690 for (i = 0; i < n; i++) {
691 dst[i][0] =
692 dst[i][1] =
693 dst[i][2] = s[i] * (1.0F / 0xffffffff);
694 dst[i][3] = 1.0F;
695 }
696 }
697
698 static void
699 unpack_Z32_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
700 {
701 const GLfloat *s = ((const GLfloat *) src);
702 GLuint i;
703 for (i = 0; i < n; i++) {
704 dst[i][0] =
705 dst[i][1] =
706 dst[i][2] = s[i * 2];
707 dst[i][3] = 1.0F;
708 }
709 }
710
711 static void
712 unpack_Z32_FLOAT_X24S8(const void *src, GLfloat dst[][4], GLuint n)
713 {
714 const GLfloat *s = ((const GLfloat *) src);
715 GLuint i;
716 for (i = 0; i < n; i++) {
717 dst[i][0] =
718 dst[i][1] =
719 dst[i][2] = s[i];
720 dst[i][3] = 1.0F;
721 }
722 }
723
724
725 static void
726 unpack_S8(const void *src, GLfloat dst[][4], GLuint n)
727 {
728 /* should never be used */
729 GLuint i;
730 for (i = 0; i < n; i++) {
731 dst[i][0] =
732 dst[i][1] =
733 dst[i][2] = 0.0F;
734 dst[i][3] = 1.0F;
735 }
736 }
737
738
739 static void
740 unpack_SRGB8(const void *src, GLfloat dst[][4], GLuint n)
741 {
742 const GLubyte *s = (const GLubyte *) src;
743 GLuint i;
744 for (i = 0; i < n; i++) {
745 dst[i][RCOMP] = nonlinear_to_linear(s[i*3+2]);
746 dst[i][GCOMP] = nonlinear_to_linear(s[i*3+1]);
747 dst[i][BCOMP] = nonlinear_to_linear(s[i*3+0]);
748 dst[i][ACOMP] = 1.0F;
749 }
750 }
751
752 static void
753 unpack_SRGBA8(const void *src, GLfloat dst[][4], GLuint n)
754 {
755 const GLuint *s = ((const GLuint *) src);
756 GLuint i;
757 for (i = 0; i < n; i++) {
758 dst[i][RCOMP] = nonlinear_to_linear( (s[i] >> 24) );
759 dst[i][GCOMP] = nonlinear_to_linear( (s[i] >> 16) & 0xff );
760 dst[i][BCOMP] = nonlinear_to_linear( (s[i] >> 8) & 0xff );
761 dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] & 0xff ); /* linear! */
762 }
763 }
764
765 static void
766 unpack_SARGB8(const void *src, GLfloat dst[][4], GLuint n)
767 {
768 const GLuint *s = ((const GLuint *) src);
769 GLuint i;
770 for (i = 0; i < n; i++) {
771 dst[i][RCOMP] = nonlinear_to_linear( (s[i] >> 16) & 0xff );
772 dst[i][GCOMP] = nonlinear_to_linear( (s[i] >> 8) & 0xff );
773 dst[i][BCOMP] = nonlinear_to_linear( (s[i] ) & 0xff );
774 dst[i][ACOMP] = UBYTE_TO_FLOAT( s[i] >> 24 ); /* linear! */
775 }
776 }
777
778 static void
779 unpack_SL8(const void *src, GLfloat dst[][4], GLuint n)
780 {
781 const GLubyte *s = ((const GLubyte *) src);
782 GLuint i;
783 for (i = 0; i < n; i++) {
784 dst[i][RCOMP] =
785 dst[i][GCOMP] =
786 dst[i][BCOMP] = nonlinear_to_linear(s[i]);
787 dst[i][ACOMP] = 1.0F;
788 }
789 }
790
791 static void
792 unpack_SLA8(const void *src, GLfloat dst[][4], GLuint n)
793 {
794 const GLushort *s = (const GLushort *) src;
795 GLuint i;
796 for (i = 0; i < n; i++) {
797 dst[i][RCOMP] =
798 dst[i][GCOMP] =
799 dst[i][BCOMP] = nonlinear_to_linear(s[i] & 0xff);
800 dst[i][ACOMP] = UBYTE_TO_FLOAT(s[i] >> 8); /* linear! */
801 }
802 }
803
804 static void
805 unpack_SRGB_DXT1(const void *src, GLfloat dst[][4], GLuint n)
806 {
807 }
808
809 static void
810 unpack_SRGBA_DXT1(const void *src, GLfloat dst[][4], GLuint n)
811 {
812 }
813
814 static void
815 unpack_SRGBA_DXT3(const void *src, GLfloat dst[][4], GLuint n)
816 {
817 }
818
819 static void
820 unpack_SRGBA_DXT5(const void *src, GLfloat dst[][4], GLuint n)
821 {
822 }
823
824 static void
825 unpack_RGB_FXT1(const void *src, GLfloat dst[][4], GLuint n)
826 {
827 }
828
829 static void
830 unpack_RGBA_FXT1(const void *src, GLfloat dst[][4], GLuint n)
831 {
832 }
833
834 static void
835 unpack_RGB_DXT1(const void *src, GLfloat dst[][4], GLuint n)
836 {
837 }
838
839 static void
840 unpack_RGBA_DXT1(const void *src, GLfloat dst[][4], GLuint n)
841 {
842 }
843
844 static void
845 unpack_RGBA_DXT3(const void *src, GLfloat dst[][4], GLuint n)
846 {
847 }
848
849 static void
850 unpack_RGBA_DXT5(const void *src, GLfloat dst[][4], GLuint n)
851 {
852 }
853
854
855 static void
856 unpack_RGBA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
857 {
858 const GLfloat *s = (const GLfloat *) src;
859 GLuint i;
860 for (i = 0; i < n; i++) {
861 dst[i][RCOMP] = s[i*4+0];
862 dst[i][GCOMP] = s[i*4+1];
863 dst[i][BCOMP] = s[i*4+2];
864 dst[i][ACOMP] = s[i*4+3];
865 }
866 }
867
868 static void
869 unpack_RGBA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
870 {
871 const GLhalfARB *s = (const GLhalfARB *) src;
872 GLuint i;
873 for (i = 0; i < n; i++) {
874 dst[i][RCOMP] = _mesa_half_to_float(s[i*4+0]);
875 dst[i][GCOMP] = _mesa_half_to_float(s[i*4+1]);
876 dst[i][BCOMP] = _mesa_half_to_float(s[i*4+2]);
877 dst[i][ACOMP] = _mesa_half_to_float(s[i*4+3]);
878 }
879 }
880
881 static void
882 unpack_RGB_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
883 {
884 const GLfloat *s = (const GLfloat *) src;
885 GLuint i;
886 for (i = 0; i < n; i++) {
887 dst[i][RCOMP] = s[i*3+0];
888 dst[i][GCOMP] = s[i*3+1];
889 dst[i][BCOMP] = s[i*3+2];
890 dst[i][ACOMP] = 1.0F;
891 }
892 }
893
894 static void
895 unpack_RGB_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
896 {
897 const GLhalfARB *s = (const GLhalfARB *) src;
898 GLuint i;
899 for (i = 0; i < n; i++) {
900 dst[i][RCOMP] = _mesa_half_to_float(s[i*3+0]);
901 dst[i][GCOMP] = _mesa_half_to_float(s[i*3+1]);
902 dst[i][BCOMP] = _mesa_half_to_float(s[i*3+2]);
903 dst[i][ACOMP] = 1.0F;
904 }
905 }
906
907 static void
908 unpack_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
909 {
910 const GLfloat *s = (const GLfloat *) src;
911 GLuint i;
912 for (i = 0; i < n; i++) {
913 dst[i][RCOMP] =
914 dst[i][GCOMP] =
915 dst[i][BCOMP] = 0.0F;
916 dst[i][ACOMP] = s[i];
917 }
918 }
919
920 static void
921 unpack_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
922 {
923 const GLhalfARB *s = (const GLhalfARB *) src;
924 GLuint i;
925 for (i = 0; i < n; i++) {
926 dst[i][RCOMP] =
927 dst[i][GCOMP] =
928 dst[i][BCOMP] = 0.0F;
929 dst[i][ACOMP] = _mesa_half_to_float(s[i]);
930 }
931 }
932
933 static void
934 unpack_LUMINANCE_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
935 {
936 const GLfloat *s = (const GLfloat *) src;
937 GLuint i;
938 for (i = 0; i < n; i++) {
939 dst[i][RCOMP] =
940 dst[i][GCOMP] =
941 dst[i][BCOMP] = s[i];
942 dst[i][ACOMP] = 1.0F;
943 }
944 }
945
946 static void
947 unpack_LUMINANCE_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
948 {
949 const GLhalfARB *s = (const GLhalfARB *) src;
950 GLuint i;
951 for (i = 0; i < n; i++) {
952 dst[i][RCOMP] =
953 dst[i][GCOMP] =
954 dst[i][BCOMP] = _mesa_half_to_float(s[i]);
955 dst[i][ACOMP] = 1.0F;
956 }
957 }
958
959 static void
960 unpack_LUMINANCE_ALPHA_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
961 {
962 const GLfloat *s = (const GLfloat *) src;
963 GLuint i;
964 for (i = 0; i < n; i++) {
965 dst[i][RCOMP] =
966 dst[i][GCOMP] =
967 dst[i][BCOMP] = s[i*2+0];
968 dst[i][ACOMP] = s[i*2+1];
969 }
970 }
971
972 static void
973 unpack_LUMINANCE_ALPHA_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
974 {
975 const GLhalfARB *s = (const GLhalfARB *) src;
976 GLuint i;
977 for (i = 0; i < n; i++) {
978 dst[i][RCOMP] =
979 dst[i][GCOMP] =
980 dst[i][BCOMP] = _mesa_half_to_float(s[i*2+0]);
981 dst[i][ACOMP] = _mesa_half_to_float(s[i*2+1]);
982 }
983 }
984
985 static void
986 unpack_INTENSITY_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
987 {
988 const GLfloat *s = (const GLfloat *) src;
989 GLuint i;
990 for (i = 0; i < n; i++) {
991 dst[i][RCOMP] =
992 dst[i][GCOMP] =
993 dst[i][BCOMP] =
994 dst[i][ACOMP] = s[i];
995 }
996 }
997
998 static void
999 unpack_INTENSITY_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
1000 {
1001 const GLhalfARB *s = (const GLhalfARB *) src;
1002 GLuint i;
1003 for (i = 0; i < n; i++) {
1004 dst[i][RCOMP] =
1005 dst[i][GCOMP] =
1006 dst[i][BCOMP] =
1007 dst[i][ACOMP] = _mesa_half_to_float(s[i]);
1008 }
1009 }
1010
1011 static void
1012 unpack_R_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
1013 {
1014 const GLfloat *s = (const GLfloat *) src;
1015 GLuint i;
1016 for (i = 0; i < n; i++) {
1017 dst[i][RCOMP] = s[i];
1018 dst[i][GCOMP] = 0.0F;
1019 dst[i][BCOMP] = 0.0F;
1020 dst[i][ACOMP] = 1.0F;
1021 }
1022 }
1023
1024 static void
1025 unpack_R_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
1026 {
1027 const GLhalfARB *s = (const GLhalfARB *) src;
1028 GLuint i;
1029 for (i = 0; i < n; i++) {
1030 dst[i][RCOMP] = _mesa_half_to_float(s[i]);
1031 dst[i][GCOMP] = 0.0F;
1032 dst[i][BCOMP] = 0.0F;
1033 dst[i][ACOMP] = 1.0F;
1034 }
1035 }
1036
1037 static void
1038 unpack_RG_FLOAT32(const void *src, GLfloat dst[][4], GLuint n)
1039 {
1040 const GLfloat *s = (const GLfloat *) src;
1041 GLuint i;
1042 for (i = 0; i < n; i++) {
1043 dst[i][RCOMP] = s[i*2+0];
1044 dst[i][GCOMP] = s[i*2+1];
1045 dst[i][BCOMP] = 0.0F;
1046 dst[i][ACOMP] = 1.0F;
1047 }
1048 }
1049
1050 static void
1051 unpack_RG_FLOAT16(const void *src, GLfloat dst[][4], GLuint n)
1052 {
1053 const GLhalfARB *s = (const GLhalfARB *) src;
1054 GLuint i;
1055 for (i = 0; i < n; i++) {
1056 dst[i][RCOMP] = _mesa_half_to_float(s[i*2+0]);
1057 dst[i][GCOMP] = _mesa_half_to_float(s[i*2+1]);
1058 dst[i][BCOMP] = 0.0F;
1059 dst[i][ACOMP] = 1.0F;
1060 }
1061 }
1062
1063
1064 static void
1065 unpack_RGBA_INT8(const void *src, GLfloat dst[][4], GLuint n)
1066 {
1067 const GLbyte *s = (const GLbyte *) src;
1068 GLuint i;
1069 for (i = 0; i < n; i++) {
1070 dst[i][RCOMP] = (GLfloat) s[i*4+0];
1071 dst[i][GCOMP] = (GLfloat) s[i*4+1];
1072 dst[i][BCOMP] = (GLfloat) s[i*4+2];
1073 dst[i][ACOMP] = (GLfloat) s[i*4+3];
1074 }
1075 }
1076
1077 static void
1078 unpack_RGBA_INT16(const void *src, GLfloat dst[][4], GLuint n)
1079 {
1080 const GLshort *s = (const GLshort *) src;
1081 GLuint i;
1082 for (i = 0; i < n; i++) {
1083 dst[i][RCOMP] = (GLfloat) s[i*4+0];
1084 dst[i][GCOMP] = (GLfloat) s[i*4+1];
1085 dst[i][BCOMP] = (GLfloat) s[i*4+2];
1086 dst[i][ACOMP] = (GLfloat) s[i*4+3];
1087 }
1088 }
1089
1090 static void
1091 unpack_RGBA_INT32(const void *src, GLfloat dst[][4], GLuint n)
1092 {
1093 const GLint *s = (const GLint *) src;
1094 GLuint i;
1095 for (i = 0; i < n; i++) {
1096 dst[i][RCOMP] = (GLfloat) s[i*4+0];
1097 dst[i][GCOMP] = (GLfloat) s[i*4+1];
1098 dst[i][BCOMP] = (GLfloat) s[i*4+2];
1099 dst[i][ACOMP] = (GLfloat) s[i*4+3];
1100 }
1101 }
1102
1103 static void
1104 unpack_RGBA_UINT8(const void *src, GLfloat dst[][4], GLuint n)
1105 {
1106 const GLubyte *s = (const GLubyte *) src;
1107 GLuint i;
1108 for (i = 0; i < n; i++) {
1109 dst[i][RCOMP] = (GLfloat) s[i*4+0];
1110 dst[i][GCOMP] = (GLfloat) s[i*4+1];
1111 dst[i][BCOMP] = (GLfloat) s[i*4+2];
1112 dst[i][ACOMP] = (GLfloat) s[i*4+3];
1113 }
1114 }
1115
1116 static void
1117 unpack_RGBA_UINT16(const void *src, GLfloat dst[][4], GLuint n)
1118 {
1119 const GLushort *s = (const GLushort *) src;
1120 GLuint i;
1121 for (i = 0; i < n; i++) {
1122 dst[i][RCOMP] = (GLfloat) s[i*4+0];
1123 dst[i][GCOMP] = (GLfloat) s[i*4+1];
1124 dst[i][BCOMP] = (GLfloat) s[i*4+2];
1125 dst[i][ACOMP] = (GLfloat) s[i*4+3];
1126 }
1127 }
1128
1129 static void
1130 unpack_RGBA_UINT32(const void *src, GLfloat dst[][4], GLuint n)
1131 {
1132 const GLuint *s = (const GLuint *) src;
1133 GLuint i;
1134 for (i = 0; i < n; i++) {
1135 dst[i][RCOMP] = (GLfloat) s[i*4+0];
1136 dst[i][GCOMP] = (GLfloat) s[i*4+1];
1137 dst[i][BCOMP] = (GLfloat) s[i*4+2];
1138 dst[i][ACOMP] = (GLfloat) s[i*4+3];
1139 }
1140 }
1141
1142 static void
1143 unpack_DUDV8(const void *src, GLfloat dst[][4], GLuint n)
1144 {
1145 const GLbyte *s = (const GLbyte *) src;
1146 GLuint i;
1147 for (i = 0; i < n; i++) {
1148 dst[i][RCOMP] = BYTE_TO_FLOAT(s[i*2+0]);
1149 dst[i][GCOMP] = BYTE_TO_FLOAT(s[i*2+1]);
1150 dst[i][BCOMP] = 0;
1151 dst[i][ACOMP] = 0;
1152 }
1153 }
1154
1155 static void
1156 unpack_SIGNED_R8(const void *src, GLfloat dst[][4], GLuint n)
1157 {
1158 const GLbyte *s = ((const GLbyte *) src);
1159 GLuint i;
1160 for (i = 0; i < n; i++) {
1161 dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( s[i] );
1162 dst[i][GCOMP] = 0.0F;
1163 dst[i][BCOMP] = 0.0F;
1164 dst[i][ACOMP] = 1.0F;
1165 }
1166 }
1167
1168 static void
1169 unpack_SIGNED_RG88_REV(const void *src, GLfloat dst[][4], GLuint n)
1170 {
1171 const GLushort *s = ((const GLushort *) src);
1172 GLuint i;
1173 for (i = 0; i < n; i++) {
1174 dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] & 0xff) );
1175 dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) );
1176 dst[i][BCOMP] = 0.0F;
1177 dst[i][ACOMP] = 1.0F;
1178 }
1179 }
1180
1181 static void
1182 unpack_SIGNED_RGBX8888(const void *src, GLfloat dst[][4], GLuint n)
1183 {
1184 const GLuint *s = ((const GLuint *) src);
1185 GLuint i;
1186 for (i = 0; i < n; i++) {
1187 dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 24) );
1188 dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 16) );
1189 dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) );
1190 dst[i][ACOMP] = 1.0f;
1191 }
1192 }
1193
1194 static void
1195 unpack_SIGNED_RGBA8888(const void *src, GLfloat dst[][4], GLuint n)
1196 {
1197 const GLuint *s = ((const GLuint *) src);
1198 GLuint i;
1199 for (i = 0; i < n; i++) {
1200 dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 24) );
1201 dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 16) );
1202 dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) );
1203 dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] ) );
1204 }
1205 }
1206
1207 static void
1208 unpack_SIGNED_RGBA8888_REV(const void *src, GLfloat dst[][4], GLuint n)
1209 {
1210 const GLuint *s = ((const GLuint *) src);
1211 GLuint i;
1212 for (i = 0; i < n; i++) {
1213 dst[i][RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] ) );
1214 dst[i][GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) );
1215 dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 16) );
1216 dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 24) );
1217 }
1218 }
1219
1220 static void
1221 unpack_SIGNED_R16(const void *src, GLfloat dst[][4], GLuint n)
1222 {
1223 const GLshort *s = ((const GLshort *) src);
1224 GLuint i;
1225 for (i = 0; i < n; i++) {
1226 dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i] );
1227 dst[i][GCOMP] = 0.0F;
1228 dst[i][BCOMP] = 0.0F;
1229 dst[i][ACOMP] = 1.0F;
1230 }
1231 }
1232
1233 static void
1234 unpack_SIGNED_GR1616(const void *src, GLfloat dst[][4], GLuint n)
1235 {
1236 const GLuint *s = ((const GLuint *) src);
1237 GLuint i;
1238 for (i = 0; i < n; i++) {
1239 dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( (GLshort) (s[i] & 0xffff) );
1240 dst[i][GCOMP] = SHORT_TO_FLOAT_TEX( (GLshort) (s[i] >> 16) );
1241 dst[i][BCOMP] = 0.0F;
1242 dst[i][ACOMP] = 1.0F;
1243 }
1244 }
1245
1246 static void
1247 unpack_SIGNED_RGB_16(const void *src, GLfloat dst[][4], GLuint n)
1248 {
1249 const GLshort *s = (const GLshort *) src;
1250 GLuint i;
1251 for (i = 0; i < n; i++) {
1252 dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i*3+0] );
1253 dst[i][GCOMP] = SHORT_TO_FLOAT_TEX( s[i*3+1] );
1254 dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i*3+2] );
1255 dst[i][ACOMP] = 1.0F;
1256 }
1257 }
1258
1259 static void
1260 unpack_SIGNED_RGBA_16(const void *src, GLfloat dst[][4], GLuint n)
1261 {
1262 const GLshort *s = (const GLshort *) src;
1263 GLuint i;
1264 for (i = 0; i < n; i++) {
1265 dst[i][RCOMP] = SHORT_TO_FLOAT_TEX( s[i*4+0] );
1266 dst[i][GCOMP] = SHORT_TO_FLOAT_TEX( s[i*4+1] );
1267 dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i*4+2] );
1268 dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i*4+3] );
1269 }
1270 }
1271
1272 static void
1273 unpack_RGBA_16(const void *src, GLfloat dst[][4], GLuint n)
1274 {
1275 const GLushort *s = (const GLushort *) src;
1276 GLuint i;
1277 for (i = 0; i < n; i++) {
1278 dst[i][RCOMP] = USHORT_TO_FLOAT( s[i*4+0] );
1279 dst[i][GCOMP] = USHORT_TO_FLOAT( s[i*4+1] );
1280 dst[i][BCOMP] = USHORT_TO_FLOAT( s[i*4+2] );
1281 dst[i][ACOMP] = USHORT_TO_FLOAT( s[i*4+3] );
1282 }
1283 }
1284
1285 static void
1286 unpack_RED_RGTC1(const void *src, GLfloat dst[][4], GLuint n)
1287 {
1288 /* XXX to do */
1289 }
1290
1291 static void
1292 unpack_SIGNED_RED_RGTC1(const void *src, GLfloat dst[][4], GLuint n)
1293 {
1294 /* XXX to do */
1295 }
1296
1297 static void
1298 unpack_RG_RGTC2(const void *src, GLfloat dst[][4], GLuint n)
1299 {
1300 /* XXX to do */
1301 }
1302
1303 static void
1304 unpack_SIGNED_RG_RGTC2(const void *src, GLfloat dst[][4], GLuint n)
1305 {
1306 /* XXX to do */
1307 }
1308
1309 static void
1310 unpack_L_LATC1(const void *src, GLfloat dst[][4], GLuint n)
1311 {
1312 /* XXX to do */
1313 }
1314
1315 static void
1316 unpack_SIGNED_L_LATC1(const void *src, GLfloat dst[][4], GLuint n)
1317 {
1318 /* XXX to do */
1319 }
1320
1321 static void
1322 unpack_LA_LATC2(const void *src, GLfloat dst[][4], GLuint n)
1323 {
1324 /* XXX to do */
1325 }
1326
1327 static void
1328 unpack_SIGNED_LA_LATC2(const void *src, GLfloat dst[][4], GLuint n)
1329 {
1330 /* XXX to do */
1331 }
1332
1333 static void
1334 unpack_ETC1_RGB8(const void *src, GLfloat dst[][4], GLuint n)
1335 {
1336 /* XXX to do */
1337 }
1338
1339 static void
1340 unpack_ETC2_RGB8(const void *src, GLfloat dst[][4], GLuint n)
1341 {
1342 /* XXX to do */
1343 }
1344
1345 static void
1346 unpack_ETC2_SRGB8(const void *src, GLfloat dst[][4], GLuint n)
1347 {
1348 /* XXX to do */
1349 }
1350
1351 static void
1352 unpack_ETC2_RGBA8_EAC(const void *src, GLfloat dst[][4], GLuint n)
1353 {
1354 /* XXX to do */
1355 }
1356
1357 static void
1358 unpack_ETC2_SRGB8_ALPHA8_EAC(const void *src, GLfloat dst[][4], GLuint n)
1359 {
1360 /* XXX to do */
1361 }
1362
1363 static void
1364 unpack_ETC2_R11_EAC(const void *src, GLfloat dst[][4], GLuint n)
1365 {
1366 /* XXX to do */
1367 }
1368
1369 static void
1370 unpack_ETC2_RG11_EAC(const void *src, GLfloat dst[][4], GLuint n)
1371 {
1372 /* XXX to do */
1373 }
1374
1375 static void
1376 unpack_ETC2_SIGNED_R11_EAC(const void *src, GLfloat dst[][4], GLuint n)
1377 {
1378 /* XXX to do */
1379 }
1380
1381 static void
1382 unpack_ETC2_SIGNED_RG11_EAC(const void *src, GLfloat dst[][4], GLuint n)
1383 {
1384 /* XXX to do */
1385 }
1386
1387 static void
1388 unpack_ETC2_RGB8_PUNCHTHROUGH_ALPHA1(const void *src, GLfloat dst[][4],
1389 GLuint n)
1390 {
1391 /* XXX to do */
1392 }
1393
1394 static void
1395 unpack_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1(const void *src, GLfloat dst[][4],
1396 GLuint n)
1397 {
1398 /* XXX to do */
1399 }
1400
1401 static void
1402 unpack_SIGNED_A8(const void *src, GLfloat dst[][4], GLuint n)
1403 {
1404 const GLbyte *s = ((const GLbyte *) src);
1405 GLuint i;
1406 for (i = 0; i < n; i++) {
1407 dst[i][RCOMP] = 0.0F;
1408 dst[i][GCOMP] = 0.0F;
1409 dst[i][BCOMP] = 0.0F;
1410 dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( s[i] );
1411 }
1412 }
1413
1414 static void
1415 unpack_SIGNED_L8(const void *src, GLfloat dst[][4], GLuint n)
1416 {
1417 const GLbyte *s = ((const GLbyte *) src);
1418 GLuint i;
1419 for (i = 0; i < n; i++) {
1420 dst[i][RCOMP] =
1421 dst[i][GCOMP] =
1422 dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( s[i] );
1423 dst[i][ACOMP] = 1.0F;
1424 }
1425 }
1426
1427 static void
1428 unpack_SIGNED_AL88(const void *src, GLfloat dst[][4], GLuint n)
1429 {
1430 const GLshort *s = ((const GLshort *) src);
1431 GLuint i;
1432 for (i = 0; i < n; i++) {
1433 dst[i][RCOMP] =
1434 dst[i][GCOMP] =
1435 dst[i][BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] & 0xff) );
1436 dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s[i] >> 8) );
1437 }
1438 }
1439
1440 static void
1441 unpack_SIGNED_I8(const void *src, GLfloat dst[][4], GLuint n)
1442 {
1443 const GLbyte *s = ((const GLbyte *) src);
1444 GLuint i;
1445 for (i = 0; i < n; i++) {
1446 dst[i][RCOMP] =
1447 dst[i][GCOMP] =
1448 dst[i][BCOMP] =
1449 dst[i][ACOMP] = BYTE_TO_FLOAT_TEX( s[i] );
1450 }
1451 }
1452
1453 static void
1454 unpack_SIGNED_A16(const void *src, GLfloat dst[][4], GLuint n)
1455 {
1456 const GLshort *s = ((const GLshort *) src);
1457 GLuint i;
1458 for (i = 0; i < n; i++) {
1459 dst[i][RCOMP] = 0.0F;
1460 dst[i][GCOMP] = 0.0F;
1461 dst[i][BCOMP] = 0.0F;
1462 dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i] );
1463 }
1464 }
1465
1466 static void
1467 unpack_SIGNED_L16(const void *src, GLfloat dst[][4], GLuint n)
1468 {
1469 const GLshort *s = ((const GLshort *) src);
1470 GLuint i;
1471 for (i = 0; i < n; i++) {
1472 dst[i][RCOMP] =
1473 dst[i][GCOMP] =
1474 dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i] );
1475 dst[i][ACOMP] = 1.0F;
1476 }
1477 }
1478
1479 static void
1480 unpack_SIGNED_AL1616(const void *src, GLfloat dst[][4], GLuint n)
1481 {
1482 const GLshort *s = (const GLshort *) src;
1483 GLuint i;
1484 for (i = 0; i < n; i++) {
1485 dst[i][RCOMP] =
1486 dst[i][GCOMP] =
1487 dst[i][BCOMP] = SHORT_TO_FLOAT_TEX( s[i*2+0] );
1488 dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i*2+1] );
1489 }
1490 }
1491
1492 static void
1493 unpack_SIGNED_I16(const void *src, GLfloat dst[][4], GLuint n)
1494 {
1495 const GLshort *s = ((const GLshort *) src);
1496 GLuint i;
1497 for (i = 0; i < n; i++) {
1498 dst[i][RCOMP] =
1499 dst[i][GCOMP] =
1500 dst[i][BCOMP] =
1501 dst[i][ACOMP] = SHORT_TO_FLOAT_TEX( s[i] );
1502 }
1503 }
1504
1505 static void
1506 unpack_RGB9_E5_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
1507 {
1508 const GLuint *s = (const GLuint *) src;
1509 GLuint i;
1510 for (i = 0; i < n; i++) {
1511 rgb9e5_to_float3(s[i], dst[i]);
1512 dst[i][ACOMP] = 1.0F;
1513 }
1514 }
1515
1516 static void
1517 unpack_R11_G11_B10_FLOAT(const void *src, GLfloat dst[][4], GLuint n)
1518 {
1519 const GLuint *s = (const GLuint *) src;
1520 GLuint i;
1521 for (i = 0; i < n; i++) {
1522 r11g11b10f_to_float3(s[i], dst[i]);
1523 dst[i][ACOMP] = 1.0F;
1524 }
1525 }
1526
1527
1528 /**
1529 * Return the unpacker function for the given format.
1530 */
1531 static unpack_rgba_func
1532 get_unpack_rgba_function(gl_format format)
1533 {
1534 static unpack_rgba_func table[MESA_FORMAT_COUNT];
1535 static GLboolean initialized = GL_FALSE;
1536
1537 if (!initialized) {
1538 table[MESA_FORMAT_NONE] = NULL;
1539
1540 table[MESA_FORMAT_RGBA8888] = unpack_RGBA8888;
1541 table[MESA_FORMAT_RGBA8888_REV] = unpack_RGBA8888_REV;
1542 table[MESA_FORMAT_ARGB8888] = unpack_ARGB8888;
1543 table[MESA_FORMAT_ARGB8888_REV] = unpack_ARGB8888_REV;
1544 table[MESA_FORMAT_RGBX8888] = unpack_RGBX8888;
1545 table[MESA_FORMAT_RGBX8888_REV] = unpack_RGBX8888_REV;
1546 table[MESA_FORMAT_XRGB8888] = unpack_XRGB8888;
1547 table[MESA_FORMAT_XRGB8888_REV] = unpack_XRGB8888_REV;
1548 table[MESA_FORMAT_RGB888] = unpack_RGB888;
1549 table[MESA_FORMAT_BGR888] = unpack_BGR888;
1550 table[MESA_FORMAT_RGB565] = unpack_RGB565;
1551 table[MESA_FORMAT_RGB565_REV] = unpack_RGB565_REV;
1552 table[MESA_FORMAT_ARGB4444] = unpack_ARGB4444;
1553 table[MESA_FORMAT_ARGB4444_REV] = unpack_ARGB4444_REV;
1554 table[MESA_FORMAT_RGBA5551] = unpack_RGBA5551;
1555 table[MESA_FORMAT_ARGB1555] = unpack_ARGB1555;
1556 table[MESA_FORMAT_ARGB1555_REV] = unpack_ARGB1555_REV;
1557 table[MESA_FORMAT_AL44] = unpack_AL44;
1558 table[MESA_FORMAT_AL88] = unpack_AL88;
1559 table[MESA_FORMAT_AL88_REV] = unpack_AL88_REV;
1560 table[MESA_FORMAT_AL1616] = unpack_AL1616;
1561 table[MESA_FORMAT_AL1616_REV] = unpack_AL1616_REV;
1562 table[MESA_FORMAT_RGB332] = unpack_RGB332;
1563 table[MESA_FORMAT_A8] = unpack_A8;
1564 table[MESA_FORMAT_A16] = unpack_A16;
1565 table[MESA_FORMAT_L8] = unpack_L8;
1566 table[MESA_FORMAT_L16] = unpack_L16;
1567 table[MESA_FORMAT_I8] = unpack_I8;
1568 table[MESA_FORMAT_I16] = unpack_I16;
1569 table[MESA_FORMAT_YCBCR] = unpack_YCBCR;
1570 table[MESA_FORMAT_YCBCR_REV] = unpack_YCBCR_REV;
1571 table[MESA_FORMAT_R8] = unpack_R8;
1572 table[MESA_FORMAT_GR88] = unpack_GR88;
1573 table[MESA_FORMAT_RG88] = unpack_RG88;
1574 table[MESA_FORMAT_R16] = unpack_R16;
1575 table[MESA_FORMAT_RG1616] = unpack_RG1616;
1576 table[MESA_FORMAT_RG1616_REV] = unpack_RG1616_REV;
1577 table[MESA_FORMAT_ARGB2101010] = unpack_ARGB2101010;
1578 table[MESA_FORMAT_ABGR2101010_UINT] = unpack_ABGR2101010_UINT;
1579 table[MESA_FORMAT_Z24_S8] = unpack_Z24_S8;
1580 table[MESA_FORMAT_S8_Z24] = unpack_S8_Z24;
1581 table[MESA_FORMAT_Z16] = unpack_Z16;
1582 table[MESA_FORMAT_X8_Z24] = unpack_X8_Z24;
1583 table[MESA_FORMAT_Z24_X8] = unpack_Z24_X8;
1584 table[MESA_FORMAT_Z32] = unpack_Z32;
1585 table[MESA_FORMAT_S8] = unpack_S8;
1586 table[MESA_FORMAT_SRGB8] = unpack_SRGB8;
1587 table[MESA_FORMAT_SRGBA8] = unpack_SRGBA8;
1588 table[MESA_FORMAT_SARGB8] = unpack_SARGB8;
1589 table[MESA_FORMAT_SL8] = unpack_SL8;
1590 table[MESA_FORMAT_SLA8] = unpack_SLA8;
1591 table[MESA_FORMAT_SRGB_DXT1] = unpack_SRGB_DXT1;
1592 table[MESA_FORMAT_SRGBA_DXT1] = unpack_SRGBA_DXT1;
1593 table[MESA_FORMAT_SRGBA_DXT3] = unpack_SRGBA_DXT3;
1594 table[MESA_FORMAT_SRGBA_DXT5] = unpack_SRGBA_DXT5;
1595
1596 table[MESA_FORMAT_RGB_FXT1] = unpack_RGB_FXT1;
1597 table[MESA_FORMAT_RGBA_FXT1] = unpack_RGBA_FXT1;
1598 table[MESA_FORMAT_RGB_DXT1] = unpack_RGB_DXT1;
1599 table[MESA_FORMAT_RGBA_DXT1] = unpack_RGBA_DXT1;
1600 table[MESA_FORMAT_RGBA_DXT3] = unpack_RGBA_DXT3;
1601 table[MESA_FORMAT_RGBA_DXT5] = unpack_RGBA_DXT5;
1602
1603 table[MESA_FORMAT_RGBA_FLOAT32] = unpack_RGBA_FLOAT32;
1604 table[MESA_FORMAT_RGBA_FLOAT16] = unpack_RGBA_FLOAT16;
1605 table[MESA_FORMAT_RGB_FLOAT32] = unpack_RGB_FLOAT32;
1606 table[MESA_FORMAT_RGB_FLOAT16] = unpack_RGB_FLOAT16;
1607 table[MESA_FORMAT_ALPHA_FLOAT32] = unpack_ALPHA_FLOAT32;
1608 table[MESA_FORMAT_ALPHA_FLOAT16] = unpack_ALPHA_FLOAT16;
1609 table[MESA_FORMAT_LUMINANCE_FLOAT32] = unpack_LUMINANCE_FLOAT32;
1610 table[MESA_FORMAT_LUMINANCE_FLOAT16] = unpack_LUMINANCE_FLOAT16;
1611 table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = unpack_LUMINANCE_ALPHA_FLOAT32;
1612 table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = unpack_LUMINANCE_ALPHA_FLOAT16;
1613 table[MESA_FORMAT_INTENSITY_FLOAT32] = unpack_INTENSITY_FLOAT32;
1614 table[MESA_FORMAT_INTENSITY_FLOAT16] = unpack_INTENSITY_FLOAT16;
1615 table[MESA_FORMAT_R_FLOAT32] = unpack_R_FLOAT32;
1616 table[MESA_FORMAT_R_FLOAT16] = unpack_R_FLOAT16;
1617 table[MESA_FORMAT_RG_FLOAT32] = unpack_RG_FLOAT32;
1618 table[MESA_FORMAT_RG_FLOAT16] = unpack_RG_FLOAT16;
1619
1620 table[MESA_FORMAT_RGBA_INT8] = unpack_RGBA_INT8;
1621 table[MESA_FORMAT_RGBA_INT16] = unpack_RGBA_INT16;
1622 table[MESA_FORMAT_RGBA_INT32] = unpack_RGBA_INT32;
1623 table[MESA_FORMAT_RGBA_UINT8] = unpack_RGBA_UINT8;
1624 table[MESA_FORMAT_RGBA_UINT16] = unpack_RGBA_UINT16;
1625 table[MESA_FORMAT_RGBA_UINT32] = unpack_RGBA_UINT32;
1626
1627 table[MESA_FORMAT_DUDV8] = unpack_DUDV8;
1628 table[MESA_FORMAT_SIGNED_R8] = unpack_SIGNED_R8;
1629 table[MESA_FORMAT_SIGNED_RG88_REV] = unpack_SIGNED_RG88_REV;
1630 table[MESA_FORMAT_SIGNED_RGBX8888] = unpack_SIGNED_RGBX8888;
1631 table[MESA_FORMAT_SIGNED_RGBA8888] = unpack_SIGNED_RGBA8888;
1632 table[MESA_FORMAT_SIGNED_RGBA8888_REV] = unpack_SIGNED_RGBA8888_REV;
1633 table[MESA_FORMAT_SIGNED_R16] = unpack_SIGNED_R16;
1634 table[MESA_FORMAT_SIGNED_GR1616] = unpack_SIGNED_GR1616;
1635 table[MESA_FORMAT_SIGNED_RGB_16] = unpack_SIGNED_RGB_16;
1636 table[MESA_FORMAT_SIGNED_RGBA_16] = unpack_SIGNED_RGBA_16;
1637 table[MESA_FORMAT_RGBA_16] = unpack_RGBA_16;
1638
1639 table[MESA_FORMAT_RED_RGTC1] = unpack_RED_RGTC1;
1640 table[MESA_FORMAT_SIGNED_RED_RGTC1] = unpack_SIGNED_RED_RGTC1;
1641 table[MESA_FORMAT_RG_RGTC2] = unpack_RG_RGTC2;
1642 table[MESA_FORMAT_SIGNED_RG_RGTC2] = unpack_SIGNED_RG_RGTC2;
1643
1644 table[MESA_FORMAT_L_LATC1] = unpack_L_LATC1;
1645 table[MESA_FORMAT_SIGNED_L_LATC1] = unpack_SIGNED_L_LATC1;
1646 table[MESA_FORMAT_LA_LATC2] = unpack_LA_LATC2;
1647 table[MESA_FORMAT_SIGNED_LA_LATC2] = unpack_SIGNED_LA_LATC2;
1648
1649 table[MESA_FORMAT_ETC1_RGB8] = unpack_ETC1_RGB8;
1650 table[MESA_FORMAT_ETC2_RGB8] = unpack_ETC2_RGB8;
1651 table[MESA_FORMAT_ETC2_SRGB8] = unpack_ETC2_SRGB8;
1652 table[MESA_FORMAT_ETC2_RGBA8_EAC] = unpack_ETC2_RGBA8_EAC;
1653 table[MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC] = unpack_ETC2_SRGB8_ALPHA8_EAC;
1654 table[MESA_FORMAT_ETC2_R11_EAC] = unpack_ETC2_R11_EAC;
1655 table[MESA_FORMAT_ETC2_RG11_EAC] = unpack_ETC2_RG11_EAC;
1656 table[MESA_FORMAT_ETC2_SIGNED_R11_EAC] = unpack_ETC2_SIGNED_R11_EAC;
1657 table[MESA_FORMAT_ETC2_SIGNED_RG11_EAC] = unpack_ETC2_SIGNED_RG11_EAC;
1658 table[MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1] =
1659 unpack_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
1660 table[MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1] =
1661 unpack_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
1662 table[MESA_FORMAT_SIGNED_A8] = unpack_SIGNED_A8;
1663 table[MESA_FORMAT_SIGNED_L8] = unpack_SIGNED_L8;
1664 table[MESA_FORMAT_SIGNED_AL88] = unpack_SIGNED_AL88;
1665 table[MESA_FORMAT_SIGNED_I8] = unpack_SIGNED_I8;
1666 table[MESA_FORMAT_SIGNED_A16] = unpack_SIGNED_A16;
1667 table[MESA_FORMAT_SIGNED_L16] = unpack_SIGNED_L16;
1668 table[MESA_FORMAT_SIGNED_AL1616] = unpack_SIGNED_AL1616;
1669 table[MESA_FORMAT_SIGNED_I16] = unpack_SIGNED_I16;
1670
1671 table[MESA_FORMAT_RGB9_E5_FLOAT] = unpack_RGB9_E5_FLOAT;
1672 table[MESA_FORMAT_R11_G11_B10_FLOAT] = unpack_R11_G11_B10_FLOAT;
1673
1674 table[MESA_FORMAT_Z32_FLOAT] = unpack_Z32_FLOAT;
1675 table[MESA_FORMAT_Z32_FLOAT_X24S8] = unpack_Z32_FLOAT_X24S8;
1676
1677 initialized = GL_TRUE;
1678 }
1679
1680 if (table[format] == NULL) {
1681 _mesa_problem(NULL, "unsupported unpack for format %s",
1682 _mesa_get_format_name(format));
1683 }
1684
1685 return table[format];
1686 }
1687
1688
1689 /**
1690 * Unpack rgba colors, returning as GLfloat values.
1691 */
1692 void
1693 _mesa_unpack_rgba_row(gl_format format, GLuint n,
1694 const void *src, GLfloat dst[][4])
1695 {
1696 unpack_rgba_func unpack = get_unpack_rgba_function(format);
1697 unpack(src, dst, n);
1698 }
1699
1700
1701 /**********************************************************************/
1702 /* Unpack, returning GLubyte colors */
1703 /**********************************************************************/
1704
1705
1706 static void
1707 unpack_ubyte_RGBA8888(const void *src, GLubyte dst[][4], GLuint n)
1708 {
1709 const GLuint *s = ((const GLuint *) src);
1710 GLuint i;
1711 for (i = 0; i < n; i++) {
1712 dst[i][RCOMP] = (s[i] >> 24);
1713 dst[i][GCOMP] = (s[i] >> 16) & 0xff;
1714 dst[i][BCOMP] = (s[i] >> 8) & 0xff;
1715 dst[i][ACOMP] = (s[i] ) & 0xff;
1716 }
1717 }
1718
1719 static void
1720 unpack_ubyte_RGBA8888_REV(const void *src, GLubyte dst[][4], GLuint n)
1721 {
1722 const GLuint *s = ((const GLuint *) src);
1723 GLuint i;
1724 for (i = 0; i < n; i++) {
1725 dst[i][RCOMP] = (s[i] ) & 0xff;
1726 dst[i][GCOMP] = (s[i] >> 8) & 0xff;
1727 dst[i][BCOMP] = (s[i] >> 16) & 0xff;
1728 dst[i][ACOMP] = (s[i] >> 24);
1729 }
1730 }
1731
1732 static void
1733 unpack_ubyte_ARGB8888(const void *src, GLubyte dst[][4], GLuint n)
1734 {
1735 const GLuint *s = ((const GLuint *) src);
1736 GLuint i;
1737 for (i = 0; i < n; i++) {
1738 dst[i][RCOMP] = (s[i] >> 16) & 0xff;
1739 dst[i][GCOMP] = (s[i] >> 8) & 0xff;
1740 dst[i][BCOMP] = (s[i] ) & 0xff;
1741 dst[i][ACOMP] = (s[i] >> 24);
1742 }
1743 }
1744
1745 static void
1746 unpack_ubyte_ARGB8888_REV(const void *src, GLubyte dst[][4], GLuint n)
1747 {
1748 const GLuint *s = ((const GLuint *) src);
1749 GLuint i;
1750 for (i = 0; i < n; i++) {
1751 dst[i][RCOMP] = (s[i] >> 8) & 0xff;
1752 dst[i][GCOMP] = (s[i] >> 16) & 0xff;
1753 dst[i][BCOMP] = (s[i] >> 24);
1754 dst[i][ACOMP] = (s[i] ) & 0xff;
1755 }
1756 }
1757
1758 static void
1759 unpack_ubyte_RGBX8888(const void *src, GLubyte dst[][4], GLuint n)
1760 {
1761 const GLuint *s = ((const GLuint *) src);
1762 GLuint i;
1763 for (i = 0; i < n; i++) {
1764 dst[i][RCOMP] = (s[i] >> 24);
1765 dst[i][GCOMP] = (s[i] >> 16) & 0xff;
1766 dst[i][BCOMP] = (s[i] >> 8) & 0xff;
1767 dst[i][ACOMP] = 0xff;
1768 }
1769 }
1770
1771 static void
1772 unpack_ubyte_RGBX8888_REV(const void *src, GLubyte dst[][4], GLuint n)
1773 {
1774 const GLuint *s = ((const GLuint *) src);
1775 GLuint i;
1776 for (i = 0; i < n; i++) {
1777 dst[i][RCOMP] = (s[i] ) & 0xff;
1778 dst[i][GCOMP] = (s[i] >> 8) & 0xff;
1779 dst[i][BCOMP] = (s[i] >> 16) & 0xff;
1780 dst[i][ACOMP] = 0xff;
1781 }
1782 }
1783
1784 static void
1785 unpack_ubyte_XRGB8888(const void *src, GLubyte dst[][4], GLuint n)
1786 {
1787 const GLuint *s = ((const GLuint *) src);
1788 GLuint i;
1789 for (i = 0; i < n; i++) {
1790 dst[i][RCOMP] = (s[i] >> 16) & 0xff;
1791 dst[i][GCOMP] = (s[i] >> 8) & 0xff;
1792 dst[i][BCOMP] = (s[i] ) & 0xff;
1793 dst[i][ACOMP] = 0xff;
1794 }
1795 }
1796
1797 static void
1798 unpack_ubyte_XRGB8888_REV(const void *src, GLubyte dst[][4], GLuint n)
1799 {
1800 const GLuint *s = ((const GLuint *) src);
1801 GLuint i;
1802 for (i = 0; i < n; i++) {
1803 dst[i][RCOMP] = (s[i] >> 8) & 0xff;
1804 dst[i][GCOMP] = (s[i] >> 16) & 0xff;
1805 dst[i][BCOMP] = (s[i] >> 24);
1806 dst[i][ACOMP] = 0xff;
1807 }
1808 }
1809
1810 static void
1811 unpack_ubyte_RGB888(const void *src, GLubyte dst[][4], GLuint n)
1812 {
1813 const GLubyte *s = (const GLubyte *) src;
1814 GLuint i;
1815 for (i = 0; i < n; i++) {
1816 dst[i][RCOMP] = s[i*3+2];
1817 dst[i][GCOMP] = s[i*3+1];
1818 dst[i][BCOMP] = s[i*3+0];
1819 dst[i][ACOMP] = 0xff;
1820 }
1821 }
1822
1823 static void
1824 unpack_ubyte_BGR888(const void *src, GLubyte dst[][4], GLuint n)
1825 {
1826 const GLubyte *s = (const GLubyte *) src;
1827 GLuint i;
1828 for (i = 0; i < n; i++) {
1829 dst[i][RCOMP] = s[i*3+0];
1830 dst[i][GCOMP] = s[i*3+1];
1831 dst[i][BCOMP] = s[i*3+2];
1832 dst[i][ACOMP] = 0xff;
1833 }
1834 }
1835
1836 static void
1837 unpack_ubyte_RGB565(const void *src, GLubyte dst[][4], GLuint n)
1838 {
1839 const GLushort *s = ((const GLushort *) src);
1840 GLuint i;
1841 for (i = 0; i < n; i++) {
1842 dst[i][RCOMP] = EXPAND_5_8((s[i] >> 11) & 0x1f);
1843 dst[i][GCOMP] = EXPAND_6_8((s[i] >> 5 ) & 0x3f);
1844 dst[i][BCOMP] = EXPAND_5_8( s[i] & 0x1f);
1845 dst[i][ACOMP] = 0xff;
1846 }
1847 }
1848
1849 static void
1850 unpack_ubyte_RGB565_REV(const void *src, GLubyte dst[][4], GLuint n)
1851 {
1852 const GLushort *s = ((const GLushort *) src);
1853 GLuint i;
1854 for (i = 0; i < n; i++) {
1855 GLuint t = (s[i] >> 8) | (s[i] << 8); /* byte swap */
1856 dst[i][RCOMP] = EXPAND_5_8((t >> 11) & 0x1f);
1857 dst[i][GCOMP] = EXPAND_6_8((t >> 5 ) & 0x3f);
1858 dst[i][BCOMP] = EXPAND_5_8( t & 0x1f);
1859 dst[i][ACOMP] = 0xff;
1860 }
1861 }
1862
1863 static void
1864 unpack_ubyte_ARGB4444(const void *src, GLubyte dst[][4], GLuint n)
1865 {
1866 const GLushort *s = ((const GLushort *) src);
1867 GLuint i;
1868 for (i = 0; i < n; i++) {
1869 dst[i][RCOMP] = EXPAND_4_8((s[i] >> 8) & 0xf);
1870 dst[i][GCOMP] = EXPAND_4_8((s[i] >> 4) & 0xf);
1871 dst[i][BCOMP] = EXPAND_4_8((s[i] ) & 0xf);
1872 dst[i][ACOMP] = EXPAND_4_8((s[i] >> 12) & 0xf);
1873 }
1874 }
1875
1876 static void
1877 unpack_ubyte_ARGB4444_REV(const void *src, GLubyte dst[][4], GLuint n)
1878 {
1879 const GLushort *s = ((const GLushort *) src);
1880 GLuint i;
1881 for (i = 0; i < n; i++) {
1882 dst[i][RCOMP] = EXPAND_4_8((s[i] ) & 0xf);
1883 dst[i][GCOMP] = EXPAND_4_8((s[i] >> 12) & 0xf);
1884 dst[i][BCOMP] = EXPAND_4_8((s[i] >> 8) & 0xf);
1885 dst[i][ACOMP] = EXPAND_4_8((s[i] >> 4) & 0xf);
1886 }
1887 }
1888
1889 static void
1890 unpack_ubyte_RGBA5551(const void *src, GLubyte dst[][4], GLuint n)
1891 {
1892 const GLushort *s = ((const GLushort *) src);
1893 GLuint i;
1894 for (i = 0; i < n; i++) {
1895 dst[i][RCOMP] = EXPAND_5_8((s[i] >> 11) & 0x1f);
1896 dst[i][GCOMP] = EXPAND_5_8((s[i] >> 6) & 0x1f);
1897 dst[i][BCOMP] = EXPAND_5_8((s[i] >> 1) & 0x1f);
1898 dst[i][ACOMP] = EXPAND_1_8((s[i] ) & 0x01);
1899 }
1900 }
1901
1902 static void
1903 unpack_ubyte_ARGB1555(const void *src, GLubyte dst[][4], GLuint n)
1904 {
1905 const GLushort *s = ((const GLushort *) src);
1906 GLuint i;
1907 for (i = 0; i < n; i++) {
1908 dst[i][RCOMP] = EXPAND_5_8((s[i] >> 10) & 0x1f);
1909 dst[i][GCOMP] = EXPAND_5_8((s[i] >> 5) & 0x1f);
1910 dst[i][BCOMP] = EXPAND_5_8((s[i] >> 0) & 0x1f);
1911 dst[i][ACOMP] = EXPAND_1_8((s[i] >> 15) & 0x01);
1912 }
1913 }
1914
1915 static void
1916 unpack_ubyte_ARGB1555_REV(const void *src, GLubyte dst[][4], GLuint n)
1917 {
1918 const GLushort *s = ((const GLushort *) src);
1919 GLuint i;
1920 for (i = 0; i < n; i++) {
1921 GLushort tmp = (s[i] << 8) | (s[i] >> 8); /* byteswap */
1922 dst[i][RCOMP] = EXPAND_5_8((tmp >> 10) & 0x1f);
1923 dst[i][GCOMP] = EXPAND_5_8((tmp >> 5) & 0x1f);
1924 dst[i][BCOMP] = EXPAND_5_8((tmp >> 0) & 0x1f);
1925 dst[i][ACOMP] = EXPAND_1_8((tmp >> 15) & 0x01);
1926 }
1927 }
1928
1929 static void
1930 unpack_ubyte_AL44(const void *src, GLubyte dst[][4], GLuint n)
1931 {
1932 const GLubyte *s = ((const GLubyte *) src);
1933 GLuint i;
1934 for (i = 0; i < n; i++) {
1935 dst[i][RCOMP] =
1936 dst[i][GCOMP] =
1937 dst[i][BCOMP] = EXPAND_4_8(s[i] & 0xf);
1938 dst[i][ACOMP] = EXPAND_4_8(s[i] >> 4);
1939 }
1940 }
1941
1942 static void
1943 unpack_ubyte_AL88(const void *src, GLubyte dst[][4], GLuint n)
1944 {
1945 const GLushort *s = ((const GLushort *) src);
1946 GLuint i;
1947 for (i = 0; i < n; i++) {
1948 dst[i][RCOMP] =
1949 dst[i][GCOMP] =
1950 dst[i][BCOMP] = EXPAND_4_8(s[i] & 0xff);
1951 dst[i][ACOMP] = EXPAND_4_8(s[i] >> 8);
1952 }
1953 }
1954
1955 static void
1956 unpack_ubyte_AL88_REV(const void *src, GLubyte dst[][4], GLuint n)
1957 {
1958 const GLushort *s = ((const GLushort *) src);
1959 GLuint i;
1960 for (i = 0; i < n; i++) {
1961 dst[i][RCOMP] =
1962 dst[i][GCOMP] =
1963 dst[i][BCOMP] = EXPAND_4_8(s[i] >> 8);
1964 dst[i][ACOMP] = EXPAND_4_8(s[i] & 0xff);
1965 }
1966 }
1967
1968 static void
1969 unpack_ubyte_RGB332(const void *src, GLubyte dst[][4], GLuint n)
1970 {
1971 const GLubyte *s = ((const GLubyte *) src);
1972 GLuint i;
1973 for (i = 0; i < n; i++) {
1974 dst[i][RCOMP] = EXPAND_3_8((s[i] >> 5) & 0x7);
1975 dst[i][GCOMP] = EXPAND_3_8((s[i] >> 2) & 0x7);
1976 dst[i][BCOMP] = EXPAND_2_8((s[i] ) & 0x3);
1977 dst[i][ACOMP] = 0xff;
1978 }
1979 }
1980
1981 static void
1982 unpack_ubyte_A8(const void *src, GLubyte dst[][4], GLuint n)
1983 {
1984 const GLubyte *s = ((const GLubyte *) src);
1985 GLuint i;
1986 for (i = 0; i < n; i++) {
1987 dst[i][RCOMP] =
1988 dst[i][GCOMP] =
1989 dst[i][BCOMP] = 0;
1990 dst[i][ACOMP] = s[i];
1991 }
1992 }
1993
1994 static void
1995 unpack_ubyte_L8(const void *src, GLubyte dst[][4], GLuint n)
1996 {
1997 const GLubyte *s = ((const GLubyte *) src);
1998 GLuint i;
1999 for (i = 0; i < n; i++) {
2000 dst[i][RCOMP] =
2001 dst[i][GCOMP] =
2002 dst[i][BCOMP] = s[i];
2003 dst[i][ACOMP] = 0xff;
2004 }
2005 }
2006
2007
2008 static void
2009 unpack_ubyte_I8(const void *src, GLubyte dst[][4], GLuint n)
2010 {
2011 const GLubyte *s = ((const GLubyte *) src);
2012 GLuint i;
2013 for (i = 0; i < n; i++) {
2014 dst[i][RCOMP] =
2015 dst[i][GCOMP] =
2016 dst[i][BCOMP] =
2017 dst[i][ACOMP] = s[i];
2018 }
2019 }
2020
2021 static void
2022 unpack_ubyte_R8(const void *src, GLubyte dst[][4], GLuint n)
2023 {
2024 const GLubyte *s = ((const GLubyte *) src);
2025 GLuint i;
2026 for (i = 0; i < n; i++) {
2027 dst[i][0] = s[i];
2028 dst[i][1] =
2029 dst[i][2] = 0;
2030 dst[i][3] = 0xff;
2031 }
2032 }
2033
2034 static void
2035 unpack_ubyte_GR88(const void *src, GLubyte dst[][4], GLuint n)
2036 {
2037 const GLushort *s = ((const GLushort *) src);
2038 GLuint i;
2039 for (i = 0; i < n; i++) {
2040 dst[i][RCOMP] = s[i] & 0xff;
2041 dst[i][GCOMP] = s[i] >> 8;
2042 dst[i][BCOMP] = 0;
2043 dst[i][ACOMP] = 0xff;
2044 }
2045 }
2046
2047 static void
2048 unpack_ubyte_RG88(const void *src, GLubyte dst[][4], GLuint n)
2049 {
2050 const GLushort *s = ((const GLushort *) src);
2051 GLuint i;
2052 for (i = 0; i < n; i++) {
2053 dst[i][RCOMP] = s[i] >> 8;
2054 dst[i][GCOMP] = s[i] & 0xff;
2055 dst[i][BCOMP] = 0;
2056 dst[i][ACOMP] = 0xff;
2057 }
2058 }
2059
2060
2061 /**
2062 * Unpack rgba colors, returning as GLubyte values. This should usually
2063 * only be used for unpacking formats that use 8 bits or less per channel.
2064 */
2065 void
2066 _mesa_unpack_ubyte_rgba_row(gl_format format, GLuint n,
2067 const void *src, GLubyte dst[][4])
2068 {
2069 switch (format) {
2070 case MESA_FORMAT_RGBA8888:
2071 unpack_ubyte_RGBA8888(src, dst, n);
2072 break;
2073 case MESA_FORMAT_RGBA8888_REV:
2074 unpack_ubyte_RGBA8888_REV(src, dst, n);
2075 break;
2076 case MESA_FORMAT_ARGB8888:
2077 unpack_ubyte_ARGB8888(src, dst, n);
2078 break;
2079 case MESA_FORMAT_ARGB8888_REV:
2080 unpack_ubyte_ARGB8888_REV(src, dst, n);
2081 break;
2082 case MESA_FORMAT_RGBX8888:
2083 unpack_ubyte_RGBX8888(src, dst, n);
2084 break;
2085 case MESA_FORMAT_RGBX8888_REV:
2086 unpack_ubyte_RGBX8888_REV(src, dst, n);
2087 break;
2088 case MESA_FORMAT_XRGB8888:
2089 unpack_ubyte_XRGB8888(src, dst, n);
2090 break;
2091 case MESA_FORMAT_XRGB8888_REV:
2092 unpack_ubyte_XRGB8888_REV(src, dst, n);
2093 break;
2094 case MESA_FORMAT_RGB888:
2095 unpack_ubyte_RGB888(src, dst, n);
2096 break;
2097 case MESA_FORMAT_BGR888:
2098 unpack_ubyte_BGR888(src, dst, n);
2099 break;
2100 case MESA_FORMAT_RGB565:
2101 unpack_ubyte_RGB565(src, dst, n);
2102 break;
2103 case MESA_FORMAT_RGB565_REV:
2104 unpack_ubyte_RGB565_REV(src, dst, n);
2105 break;
2106 case MESA_FORMAT_ARGB4444:
2107 unpack_ubyte_ARGB4444(src, dst, n);
2108 break;
2109 case MESA_FORMAT_ARGB4444_REV:
2110 unpack_ubyte_ARGB4444_REV(src, dst, n);
2111 break;
2112 case MESA_FORMAT_RGBA5551:
2113 unpack_ubyte_RGBA5551(src, dst, n);
2114 break;
2115 case MESA_FORMAT_ARGB1555:
2116 unpack_ubyte_ARGB1555(src, dst, n);
2117 break;
2118 case MESA_FORMAT_ARGB1555_REV:
2119 unpack_ubyte_ARGB1555_REV(src, dst, n);
2120 break;
2121 case MESA_FORMAT_AL44:
2122 unpack_ubyte_AL44(src, dst, n);
2123 break;
2124 case MESA_FORMAT_AL88:
2125 unpack_ubyte_AL88(src, dst, n);
2126 break;
2127 case MESA_FORMAT_AL88_REV:
2128 unpack_ubyte_AL88_REV(src, dst, n);
2129 break;
2130 case MESA_FORMAT_RGB332:
2131 unpack_ubyte_RGB332(src, dst, n);
2132 break;
2133 case MESA_FORMAT_A8:
2134 unpack_ubyte_A8(src, dst, n);
2135 break;
2136 case MESA_FORMAT_L8:
2137 unpack_ubyte_L8(src, dst, n);
2138 break;
2139 case MESA_FORMAT_I8:
2140 unpack_ubyte_I8(src, dst, n);
2141 break;
2142 case MESA_FORMAT_R8:
2143 unpack_ubyte_R8(src, dst, n);
2144 break;
2145 case MESA_FORMAT_GR88:
2146 unpack_ubyte_GR88(src, dst, n);
2147 break;
2148 case MESA_FORMAT_RG88:
2149 unpack_ubyte_RG88(src, dst, n);
2150 break;
2151 default:
2152 /* get float values, convert to ubyte */
2153 {
2154 GLfloat *tmp = malloc(n * 4 * sizeof(GLfloat));
2155 if (tmp) {
2156 GLuint i;
2157 _mesa_unpack_rgba_row(format, n, src, (GLfloat (*)[4]) tmp);
2158 for (i = 0; i < n; i++) {
2159 UNCLAMPED_FLOAT_TO_UBYTE(dst[i][0], tmp[i*4+0]);
2160 UNCLAMPED_FLOAT_TO_UBYTE(dst[i][1], tmp[i*4+1]);
2161 UNCLAMPED_FLOAT_TO_UBYTE(dst[i][2], tmp[i*4+2]);
2162 UNCLAMPED_FLOAT_TO_UBYTE(dst[i][3], tmp[i*4+3]);
2163 }
2164 free(tmp);
2165 }
2166 }
2167 break;
2168 }
2169 }
2170
2171
2172 /**********************************************************************/
2173 /* Unpack, returning GLuint colors */
2174 /**********************************************************************/
2175
2176 static void
2177 unpack_int_rgba_RGBA_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2178 {
2179 memcpy(dst, src, n * 4 * sizeof(GLuint));
2180 }
2181
2182 static void
2183 unpack_int_rgba_RGBA_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2184 {
2185 unsigned int i;
2186
2187 for (i = 0; i < n; i++) {
2188 dst[i][0] = src[i * 4 + 0];
2189 dst[i][1] = src[i * 4 + 1];
2190 dst[i][2] = src[i * 4 + 2];
2191 dst[i][3] = src[i * 4 + 3];
2192 }
2193 }
2194
2195 static void
2196 unpack_int_rgba_RGBA_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2197 {
2198 unsigned int i;
2199
2200 for (i = 0; i < n; i++) {
2201 dst[i][0] = src[i * 4 + 0];
2202 dst[i][1] = src[i * 4 + 1];
2203 dst[i][2] = src[i * 4 + 2];
2204 dst[i][3] = src[i * 4 + 3];
2205 }
2206 }
2207
2208 static void
2209 unpack_int_rgba_RGBA_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2210 {
2211 unsigned int i;
2212
2213 for (i = 0; i < n; i++) {
2214 dst[i][0] = src[i * 4 + 0];
2215 dst[i][1] = src[i * 4 + 1];
2216 dst[i][2] = src[i * 4 + 2];
2217 dst[i][3] = src[i * 4 + 3];
2218 }
2219 }
2220
2221 static void
2222 unpack_int_rgba_RGBA_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2223 {
2224 unsigned int i;
2225
2226 for (i = 0; i < n; i++) {
2227 dst[i][0] = src[i * 4 + 0];
2228 dst[i][1] = src[i * 4 + 1];
2229 dst[i][2] = src[i * 4 + 2];
2230 dst[i][3] = src[i * 4 + 3];
2231 }
2232 }
2233
2234 static void
2235 unpack_int_rgba_ARGB8888(const GLbyte *src, GLuint dst[][4], GLuint n)
2236 {
2237 unsigned int i;
2238
2239 for (i = 0; i < n; i++) {
2240 dst[i][RCOMP] = (GLubyte) src[i * 4 + 2];
2241 dst[i][GCOMP] = (GLubyte) src[i * 4 + 1];
2242 dst[i][BCOMP] = (GLubyte) src[i * 4 + 0];
2243 dst[i][ACOMP] = (GLubyte) src[i * 4 + 3];
2244 }
2245 }
2246
2247 static void
2248 unpack_int_rgba_XRGB8888(const GLbyte *src, GLuint dst[][4], GLuint n)
2249 {
2250 unsigned int i;
2251
2252 for (i = 0; i < n; i++) {
2253 dst[i][RCOMP] = (GLubyte) src[i * 4 + 2];
2254 dst[i][GCOMP] = (GLubyte) src[i * 4 + 1];
2255 dst[i][BCOMP] = (GLubyte) src[i * 4 + 0];
2256 dst[i][ACOMP] = (GLubyte) 0xff;
2257 }
2258 }
2259
2260 static void
2261 unpack_int_rgba_RGB_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2262 {
2263 unsigned int i;
2264
2265 for (i = 0; i < n; i++) {
2266 dst[i][0] = src[i * 3 + 0];
2267 dst[i][1] = src[i * 3 + 1];
2268 dst[i][2] = src[i * 3 + 2];
2269 dst[i][3] = 1;
2270 }
2271 }
2272
2273 static void
2274 unpack_int_rgba_RGB_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2275 {
2276 unsigned int i;
2277
2278 for (i = 0; i < n; i++) {
2279 dst[i][0] = src[i * 3 + 0];
2280 dst[i][1] = src[i * 3 + 1];
2281 dst[i][2] = src[i * 3 + 2];
2282 dst[i][3] = 1;
2283 }
2284 }
2285
2286 static void
2287 unpack_int_rgba_RGB_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2288 {
2289 unsigned int i;
2290
2291 for (i = 0; i < n; i++) {
2292 dst[i][0] = src[i * 3 + 0];
2293 dst[i][1] = src[i * 3 + 1];
2294 dst[i][2] = src[i * 3 + 2];
2295 dst[i][3] = 1;
2296 }
2297 }
2298
2299 static void
2300 unpack_int_rgba_RGB_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2301 {
2302 unsigned int i;
2303
2304 for (i = 0; i < n; i++) {
2305 dst[i][0] = src[i * 3 + 0];
2306 dst[i][1] = src[i * 3 + 1];
2307 dst[i][2] = src[i * 3 + 2];
2308 dst[i][3] = 1;
2309 }
2310 }
2311
2312 static void
2313 unpack_int_rgba_RGB_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2314 {
2315 unsigned int i;
2316
2317 for (i = 0; i < n; i++) {
2318 dst[i][0] = src[i * 3 + 0];
2319 dst[i][1] = src[i * 3 + 1];
2320 dst[i][2] = src[i * 3 + 2];
2321 dst[i][3] = 1;
2322 }
2323 }
2324
2325 static void
2326 unpack_int_rgba_RG_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2327 {
2328 unsigned int i;
2329
2330 for (i = 0; i < n; i++) {
2331 dst[i][0] = src[i * 2 + 0];
2332 dst[i][1] = src[i * 2 + 1];
2333 dst[i][2] = 0;
2334 dst[i][3] = 1;
2335 }
2336 }
2337
2338 static void
2339 unpack_int_rgba_RG_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2340 {
2341 unsigned int i;
2342
2343 for (i = 0; i < n; i++) {
2344 dst[i][0] = src[i * 2 + 0];
2345 dst[i][1] = src[i * 2 + 1];
2346 dst[i][2] = 0;
2347 dst[i][3] = 1;
2348 }
2349 }
2350
2351 static void
2352 unpack_int_rgba_RG_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2353 {
2354 unsigned int i;
2355
2356 for (i = 0; i < n; i++) {
2357 dst[i][0] = src[i * 2 + 0];
2358 dst[i][1] = src[i * 2 + 1];
2359 dst[i][2] = 0;
2360 dst[i][3] = 1;
2361 }
2362 }
2363
2364 static void
2365 unpack_int_rgba_RG_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2366 {
2367 unsigned int i;
2368
2369 for (i = 0; i < n; i++) {
2370 dst[i][0] = src[i * 2 + 0];
2371 dst[i][1] = src[i * 2 + 1];
2372 dst[i][2] = 0;
2373 dst[i][3] = 1;
2374 }
2375 }
2376
2377 static void
2378 unpack_int_rgba_RG_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2379 {
2380 unsigned int i;
2381
2382 for (i = 0; i < n; i++) {
2383 dst[i][0] = src[i * 2 + 0];
2384 dst[i][1] = src[i * 2 + 1];
2385 dst[i][2] = 0;
2386 dst[i][3] = 1;
2387 }
2388 }
2389
2390 static void
2391 unpack_int_rgba_R_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2392 {
2393 unsigned int i;
2394
2395 for (i = 0; i < n; i++) {
2396 dst[i][0] = src[i];
2397 dst[i][1] = 0;
2398 dst[i][2] = 0;
2399 dst[i][3] = 1;
2400 }
2401 }
2402
2403 static void
2404 unpack_int_rgba_R_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2405 {
2406 unsigned int i;
2407
2408 for (i = 0; i < n; i++) {
2409 dst[i][0] = src[i];
2410 dst[i][1] = 0;
2411 dst[i][2] = 0;
2412 dst[i][3] = 1;
2413 }
2414 }
2415
2416 static void
2417 unpack_int_rgba_R_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2418 {
2419 unsigned int i;
2420
2421 for (i = 0; i < n; i++) {
2422 dst[i][0] = src[i];
2423 dst[i][1] = 0;
2424 dst[i][2] = 0;
2425 dst[i][3] = 1;
2426 }
2427 }
2428
2429 static void
2430 unpack_int_rgba_R_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2431 {
2432 unsigned int i;
2433
2434 for (i = 0; i < n; i++) {
2435 dst[i][0] = src[i];
2436 dst[i][1] = 0;
2437 dst[i][2] = 0;
2438 dst[i][3] = 1;
2439 }
2440 }
2441
2442 static void
2443 unpack_int_rgba_R_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2444 {
2445 unsigned int i;
2446
2447 for (i = 0; i < n; i++) {
2448 dst[i][0] = src[i];
2449 dst[i][1] = 0;
2450 dst[i][2] = 0;
2451 dst[i][3] = 1;
2452 }
2453 }
2454
2455 static void
2456 unpack_int_rgba_ALPHA_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2457 {
2458 unsigned int i;
2459
2460 for (i = 0; i < n; i++) {
2461 dst[i][0] = dst[i][1] = dst[i][2] = 0;
2462 dst[i][3] = src[i];
2463 }
2464 }
2465
2466 static void
2467 unpack_int_rgba_ALPHA_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2468 {
2469 unsigned int i;
2470
2471 for (i = 0; i < n; i++) {
2472 dst[i][0] = dst[i][1] = dst[i][2] = 0;
2473 dst[i][3] = src[i];
2474 }
2475 }
2476
2477 static void
2478 unpack_int_rgba_ALPHA_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2479 {
2480 unsigned int i;
2481
2482 for (i = 0; i < n; i++) {
2483 dst[i][0] = dst[i][1] = dst[i][2] = 0;
2484 dst[i][3] = src[i];
2485 }
2486 }
2487
2488 static void
2489 unpack_int_rgba_ALPHA_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2490 {
2491 unsigned int i;
2492
2493 for (i = 0; i < n; i++) {
2494 dst[i][0] = dst[i][1] = dst[i][2] = 0;
2495 dst[i][3] = src[i];
2496 }
2497 }
2498
2499 static void
2500 unpack_int_rgba_ALPHA_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2501 {
2502 unsigned int i;
2503
2504 for (i = 0; i < n; i++) {
2505 dst[i][0] = dst[i][1] = dst[i][2] = 0;
2506 dst[i][3] = src[i];
2507 }
2508 }
2509
2510 static void
2511 unpack_int_rgba_LUMINANCE_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2512 {
2513 unsigned int i;
2514
2515 for (i = 0; i < n; i++) {
2516 dst[i][0] = dst[i][1] = dst[i][2] = src[i];
2517 dst[i][3] = 1;
2518 }
2519 }
2520
2521 static void
2522 unpack_int_rgba_LUMINANCE_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2523 {
2524 unsigned int i;
2525
2526 for (i = 0; i < n; i++) {
2527 dst[i][0] = dst[i][1] = dst[i][2] = src[i];
2528 dst[i][3] = 1;
2529 }
2530 }
2531
2532 static void
2533 unpack_int_rgba_LUMINANCE_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2534 {
2535 unsigned int i;
2536
2537 for (i = 0; i < n; i++) {
2538 dst[i][0] = dst[i][1] = dst[i][2] = src[i];
2539 dst[i][3] = 1;
2540 }
2541 }
2542
2543 static void
2544 unpack_int_rgba_LUMINANCE_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2545 {
2546 unsigned int i;
2547
2548 for (i = 0; i < n; i++) {
2549 dst[i][0] = dst[i][1] = dst[i][2] = src[i];
2550 dst[i][3] = 1;
2551 }
2552 }
2553
2554 static void
2555 unpack_int_rgba_LUMINANCE_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2556 {
2557 unsigned int i;
2558
2559 for (i = 0; i < n; i++) {
2560 dst[i][0] = dst[i][1] = dst[i][2] = src[i];
2561 dst[i][3] = 1;
2562 }
2563 }
2564
2565
2566 static void
2567 unpack_int_rgba_LUMINANCE_ALPHA_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2568 {
2569 unsigned int i;
2570
2571 for (i = 0; i < n; i++) {
2572 dst[i][0] = dst[i][1] = dst[i][2] = src[i * 2 + 0];
2573 dst[i][3] = src[i * 2 + 1];
2574 }
2575 }
2576
2577 static void
2578 unpack_int_rgba_LUMINANCE_ALPHA_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2579 {
2580 unsigned int i;
2581
2582 for (i = 0; i < n; i++) {
2583 dst[i][0] = dst[i][1] = dst[i][2] = src[i * 2 + 0];
2584 dst[i][3] = src[i * 2 + 1];
2585 }
2586 }
2587
2588 static void
2589 unpack_int_rgba_LUMINANCE_ALPHA_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2590 {
2591 unsigned int i;
2592
2593 for (i = 0; i < n; i++) {
2594 dst[i][0] = dst[i][1] = dst[i][2] = src[i * 2 + 0];
2595 dst[i][3] = src[i * 2 + 1];
2596 }
2597 }
2598
2599 static void
2600 unpack_int_rgba_LUMINANCE_ALPHA_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2601 {
2602 unsigned int i;
2603
2604 for (i = 0; i < n; i++) {
2605 dst[i][0] = dst[i][1] = dst[i][2] = src[i * 2 + 0];
2606 dst[i][3] = src[i * 2 + 1];
2607 }
2608 }
2609
2610 static void
2611 unpack_int_rgba_LUMINANCE_ALPHA_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2612 {
2613 unsigned int i;
2614
2615 for (i = 0; i < n; i++) {
2616 dst[i][0] = dst[i][1] = dst[i][2] = src[i * 2 + 0];
2617 dst[i][3] = src[i * 2 + 1];
2618 }
2619 }
2620
2621 static void
2622 unpack_int_rgba_INTENSITY_UINT32(const GLuint *src, GLuint dst[][4], GLuint n)
2623 {
2624 unsigned int i;
2625
2626 for (i = 0; i < n; i++) {
2627 dst[i][0] = dst[i][1] = dst[i][2] = dst[i][3] = src[i];
2628 }
2629 }
2630
2631 static void
2632 unpack_int_rgba_INTENSITY_UINT16(const GLushort *src, GLuint dst[][4], GLuint n)
2633 {
2634 unsigned int i;
2635
2636 for (i = 0; i < n; i++) {
2637 dst[i][0] = dst[i][1] = dst[i][2] = dst[i][3] = src[i];
2638 }
2639 }
2640
2641 static void
2642 unpack_int_rgba_INTENSITY_INT16(const GLshort *src, GLuint dst[][4], GLuint n)
2643 {
2644 unsigned int i;
2645
2646 for (i = 0; i < n; i++) {
2647 dst[i][0] = dst[i][1] = dst[i][2] = dst[i][3] = src[i];
2648 }
2649 }
2650
2651 static void
2652 unpack_int_rgba_INTENSITY_UINT8(const GLubyte *src, GLuint dst[][4], GLuint n)
2653 {
2654 unsigned int i;
2655
2656 for (i = 0; i < n; i++) {
2657 dst[i][0] = dst[i][1] = dst[i][2] = dst[i][3] = src[i];
2658 }
2659 }
2660
2661 static void
2662 unpack_int_rgba_INTENSITY_INT8(const GLbyte *src, GLuint dst[][4], GLuint n)
2663 {
2664 unsigned int i;
2665
2666 for (i = 0; i < n; i++) {
2667 dst[i][0] = dst[i][1] = dst[i][2] = dst[i][3] = src[i];
2668 }
2669 }
2670
2671 static void
2672 unpack_int_rgba_ARGB2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
2673 {
2674 unsigned int i;
2675
2676 for (i = 0; i < n; i++) {
2677 GLuint tmp = src[i];
2678 dst[i][0] = (tmp >> 20) & 0x3ff;
2679 dst[i][1] = (tmp >> 10) & 0x3ff;
2680 dst[i][2] = (tmp >> 0) & 0x3ff;
2681 dst[i][3] = (tmp >> 30) & 0x3;
2682 }
2683 }
2684
2685 static void
2686 unpack_int_rgba_ABGR2101010_UINT(const GLuint *src, GLuint dst[][4], GLuint n)
2687 {
2688 unsigned int i;
2689
2690 for (i = 0; i < n; i++) {
2691 GLuint tmp = src[i];
2692 dst[i][0] = (tmp >> 0) & 0x3ff;
2693 dst[i][1] = (tmp >> 10) & 0x3ff;
2694 dst[i][2] = (tmp >> 20) & 0x3ff;
2695 dst[i][3] = (tmp >> 30) & 0x3;
2696 }
2697 }
2698
2699 void
2700 _mesa_unpack_uint_rgba_row(gl_format format, GLuint n,
2701 const void *src, GLuint dst[][4])
2702 {
2703 switch (format) {
2704 /* Since there won't be any sign extension happening, there's no need to
2705 * make separate paths for 32-bit-to-32-bit integer unpack.
2706 */
2707 case MESA_FORMAT_RGBA_UINT32:
2708 case MESA_FORMAT_RGBA_INT32:
2709 unpack_int_rgba_RGBA_UINT32(src, dst, n);
2710 break;
2711
2712 case MESA_FORMAT_RGBA_UINT16:
2713 unpack_int_rgba_RGBA_UINT16(src, dst, n);
2714 break;
2715 case MESA_FORMAT_RGBA_INT16:
2716 unpack_int_rgba_RGBA_INT16(src, dst, n);
2717 break;
2718
2719 case MESA_FORMAT_RGBA_UINT8:
2720 unpack_int_rgba_RGBA_UINT8(src, dst, n);
2721 break;
2722 case MESA_FORMAT_RGBA_INT8:
2723 unpack_int_rgba_RGBA_INT8(src, dst, n);
2724 break;
2725
2726 case MESA_FORMAT_ARGB8888:
2727 unpack_int_rgba_ARGB8888(src, dst, n);
2728 break;
2729
2730 case MESA_FORMAT_XRGB8888:
2731 unpack_int_rgba_XRGB8888(src, dst, n);
2732 break;
2733
2734 case MESA_FORMAT_RGB_UINT32:
2735 case MESA_FORMAT_RGB_INT32:
2736 unpack_int_rgba_RGB_UINT32(src, dst, n);
2737 break;
2738
2739 case MESA_FORMAT_RGB_UINT16:
2740 unpack_int_rgba_RGB_UINT16(src, dst, n);
2741 break;
2742 case MESA_FORMAT_RGB_INT16:
2743 unpack_int_rgba_RGB_INT16(src, dst, n);
2744 break;
2745
2746 case MESA_FORMAT_RGB_UINT8:
2747 unpack_int_rgba_RGB_UINT8(src, dst, n);
2748 break;
2749 case MESA_FORMAT_RGB_INT8:
2750 unpack_int_rgba_RGB_INT8(src, dst, n);
2751 break;
2752
2753 case MESA_FORMAT_RG_UINT32:
2754 case MESA_FORMAT_RG_INT32:
2755 unpack_int_rgba_RG_UINT32(src, dst, n);
2756 break;
2757
2758 case MESA_FORMAT_RG_UINT16:
2759 unpack_int_rgba_RG_UINT16(src, dst, n);
2760 break;
2761 case MESA_FORMAT_RG_INT16:
2762 unpack_int_rgba_RG_INT16(src, dst, n);
2763 break;
2764
2765 case MESA_FORMAT_RG_UINT8:
2766 unpack_int_rgba_RG_UINT8(src, dst, n);
2767 break;
2768 case MESA_FORMAT_RG_INT8:
2769 unpack_int_rgba_RG_INT8(src, dst, n);
2770 break;
2771
2772 case MESA_FORMAT_R_UINT32:
2773 case MESA_FORMAT_R_INT32:
2774 unpack_int_rgba_R_UINT32(src, dst, n);
2775 break;
2776
2777 case MESA_FORMAT_R_UINT16:
2778 unpack_int_rgba_R_UINT16(src, dst, n);
2779 break;
2780 case MESA_FORMAT_R_INT16:
2781 unpack_int_rgba_R_INT16(src, dst, n);
2782 break;
2783
2784 case MESA_FORMAT_R_UINT8:
2785 unpack_int_rgba_R_UINT8(src, dst, n);
2786 break;
2787 case MESA_FORMAT_R_INT8:
2788 unpack_int_rgba_R_INT8(src, dst, n);
2789 break;
2790
2791 case MESA_FORMAT_ALPHA_UINT32:
2792 case MESA_FORMAT_ALPHA_INT32:
2793 unpack_int_rgba_ALPHA_UINT32(src, dst, n);
2794 break;
2795
2796 case MESA_FORMAT_ALPHA_UINT16:
2797 unpack_int_rgba_ALPHA_UINT16(src, dst, n);
2798 break;
2799 case MESA_FORMAT_ALPHA_INT16:
2800 unpack_int_rgba_ALPHA_INT16(src, dst, n);
2801 break;
2802
2803 case MESA_FORMAT_ALPHA_UINT8:
2804 unpack_int_rgba_ALPHA_UINT8(src, dst, n);
2805 break;
2806 case MESA_FORMAT_ALPHA_INT8:
2807 unpack_int_rgba_ALPHA_INT8(src, dst, n);
2808 break;
2809
2810 case MESA_FORMAT_LUMINANCE_UINT32:
2811 case MESA_FORMAT_LUMINANCE_INT32:
2812 unpack_int_rgba_LUMINANCE_UINT32(src, dst, n);
2813 break;
2814 case MESA_FORMAT_LUMINANCE_UINT16:
2815 unpack_int_rgba_LUMINANCE_UINT16(src, dst, n);
2816 break;
2817 case MESA_FORMAT_LUMINANCE_INT16:
2818 unpack_int_rgba_LUMINANCE_INT16(src, dst, n);
2819 break;
2820
2821 case MESA_FORMAT_LUMINANCE_UINT8:
2822 unpack_int_rgba_LUMINANCE_UINT8(src, dst, n);
2823 break;
2824 case MESA_FORMAT_LUMINANCE_INT8:
2825 unpack_int_rgba_LUMINANCE_INT8(src, dst, n);
2826 break;
2827
2828 case MESA_FORMAT_LUMINANCE_ALPHA_UINT32:
2829 case MESA_FORMAT_LUMINANCE_ALPHA_INT32:
2830 unpack_int_rgba_LUMINANCE_ALPHA_UINT32(src, dst, n);
2831 break;
2832
2833 case MESA_FORMAT_LUMINANCE_ALPHA_UINT16:
2834 unpack_int_rgba_LUMINANCE_ALPHA_UINT16(src, dst, n);
2835 break;
2836 case MESA_FORMAT_LUMINANCE_ALPHA_INT16:
2837 unpack_int_rgba_LUMINANCE_ALPHA_INT16(src, dst, n);
2838 break;
2839
2840 case MESA_FORMAT_LUMINANCE_ALPHA_UINT8:
2841 unpack_int_rgba_LUMINANCE_ALPHA_UINT8(src, dst, n);
2842 break;
2843 case MESA_FORMAT_LUMINANCE_ALPHA_INT8:
2844 unpack_int_rgba_LUMINANCE_ALPHA_INT8(src, dst, n);
2845 break;
2846
2847 case MESA_FORMAT_INTENSITY_UINT32:
2848 case MESA_FORMAT_INTENSITY_INT32:
2849 unpack_int_rgba_INTENSITY_UINT32(src, dst, n);
2850 break;
2851
2852 case MESA_FORMAT_INTENSITY_UINT16:
2853 unpack_int_rgba_INTENSITY_UINT16(src, dst, n);
2854 break;
2855 case MESA_FORMAT_INTENSITY_INT16:
2856 unpack_int_rgba_INTENSITY_INT16(src, dst, n);
2857 break;
2858
2859 case MESA_FORMAT_INTENSITY_UINT8:
2860 unpack_int_rgba_INTENSITY_UINT8(src, dst, n);
2861 break;
2862 case MESA_FORMAT_INTENSITY_INT8:
2863 unpack_int_rgba_INTENSITY_INT8(src, dst, n);
2864 break;
2865
2866 case MESA_FORMAT_ARGB2101010_UINT:
2867 unpack_int_rgba_ARGB2101010_UINT(src, dst, n);
2868 break;
2869
2870 case MESA_FORMAT_ABGR2101010_UINT:
2871 unpack_int_rgba_ABGR2101010_UINT(src, dst, n);
2872 break;
2873
2874 default:
2875 _mesa_problem(NULL, "%s: bad format %s", __FUNCTION__,
2876 _mesa_get_format_name(format));
2877 return;
2878 }
2879 }
2880
2881 /**
2882 * Unpack a 2D rect of pixels returning float RGBA colors.
2883 * \param format the source image format
2884 * \param src start address of the source image
2885 * \param srcRowStride source image row stride in bytes
2886 * \param dst start address of the dest image
2887 * \param dstRowStride dest image row stride in bytes
2888 * \param x source image start X pos
2889 * \param y source image start Y pos
2890 * \param width width of rect region to convert
2891 * \param height height of rect region to convert
2892 */
2893 void
2894 _mesa_unpack_rgba_block(gl_format format,
2895 const void *src, GLint srcRowStride,
2896 GLfloat dst[][4], GLint dstRowStride,
2897 GLuint x, GLuint y, GLuint width, GLuint height)
2898 {
2899 unpack_rgba_func unpack = get_unpack_rgba_function(format);
2900 const GLuint srcPixStride = _mesa_get_format_bytes(format);
2901 const GLuint dstPixStride = 4 * sizeof(GLfloat);
2902 const GLubyte *srcRow;
2903 GLubyte *dstRow;
2904 GLuint i;
2905
2906 /* XXX needs to be fixed for compressed formats */
2907
2908 srcRow = ((const GLubyte *) src) + srcRowStride * y + srcPixStride * x;
2909 dstRow = ((GLubyte *) dst) + dstRowStride * y + dstPixStride * x;
2910
2911 for (i = 0; i < height; i++) {
2912 unpack(srcRow, (GLfloat (*)[4]) dstRow, width);
2913
2914 dstRow += dstRowStride;
2915 srcRow += srcRowStride;
2916 }
2917 }
2918
2919
2920
2921
2922 typedef void (*unpack_float_z_func)(GLuint n, const void *src, GLfloat *dst);
2923
2924 static void
2925 unpack_float_z_Z24_X8(GLuint n, const void *src, GLfloat *dst)
2926 {
2927 /* only return Z, not stencil data */
2928 const GLuint *s = ((const GLuint *) src);
2929 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
2930 GLuint i;
2931 for (i = 0; i < n; i++) {
2932 dst[i] = (GLfloat) ((s[i] >> 8) * scale);
2933 ASSERT(dst[i] >= 0.0F);
2934 ASSERT(dst[i] <= 1.0F);
2935 }
2936 }
2937
2938 static void
2939 unpack_float_z_X8_Z24(GLuint n, const void *src, GLfloat *dst)
2940 {
2941 /* only return Z, not stencil data */
2942 const GLuint *s = ((const GLuint *) src);
2943 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
2944 GLuint i;
2945 for (i = 0; i < n; i++) {
2946 dst[i] = (GLfloat) ((s[i] & 0x00ffffff) * scale);
2947 ASSERT(dst[i] >= 0.0F);
2948 ASSERT(dst[i] <= 1.0F);
2949 }
2950 }
2951
2952 static void
2953 unpack_float_z_Z16(GLuint n, const void *src, GLfloat *dst)
2954 {
2955 const GLushort *s = ((const GLushort *) src);
2956 GLuint i;
2957 for (i = 0; i < n; i++) {
2958 dst[i] = s[i] * (1.0F / 65535.0F);
2959 }
2960 }
2961
2962 static void
2963 unpack_float_z_Z32(GLuint n, const void *src, GLfloat *dst)
2964 {
2965 const GLuint *s = ((const GLuint *) src);
2966 GLuint i;
2967 for (i = 0; i < n; i++) {
2968 dst[i] = s[i] * (1.0F / 0xffffffff);
2969 }
2970 }
2971
2972 static void
2973 unpack_float_z_Z32F(GLuint n, const void *src, GLfloat *dst)
2974 {
2975 memcpy(dst, src, n * sizeof(float));
2976 }
2977
2978 static void
2979 unpack_float_z_Z32X24S8(GLuint n, const void *src, GLfloat *dst)
2980 {
2981 const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
2982 GLuint i;
2983 for (i = 0; i < n; i++) {
2984 dst[i] = s[i].z;
2985 }
2986 }
2987
2988
2989
2990 /**
2991 * Unpack Z values.
2992 * The returned values will always be in the range [0.0, 1.0].
2993 */
2994 void
2995 _mesa_unpack_float_z_row(gl_format format, GLuint n,
2996 const void *src, GLfloat *dst)
2997 {
2998 unpack_float_z_func unpack;
2999
3000 switch (format) {
3001 case MESA_FORMAT_Z24_S8:
3002 case MESA_FORMAT_Z24_X8:
3003 unpack = unpack_float_z_Z24_X8;
3004 break;
3005 case MESA_FORMAT_S8_Z24:
3006 case MESA_FORMAT_X8_Z24:
3007 unpack = unpack_float_z_X8_Z24;
3008 break;
3009 case MESA_FORMAT_Z16:
3010 unpack = unpack_float_z_Z16;
3011 break;
3012 case MESA_FORMAT_Z32:
3013 unpack = unpack_float_z_Z32;
3014 break;
3015 case MESA_FORMAT_Z32_FLOAT:
3016 unpack = unpack_float_z_Z32F;
3017 break;
3018 case MESA_FORMAT_Z32_FLOAT_X24S8:
3019 unpack = unpack_float_z_Z32X24S8;
3020 break;
3021 default:
3022 _mesa_problem(NULL, "bad format %s in _mesa_unpack_float_z_row",
3023 _mesa_get_format_name(format));
3024 return;
3025 }
3026
3027 unpack(n, src, dst);
3028 }
3029
3030
3031
3032 typedef void (*unpack_uint_z_func)(const void *src, GLuint *dst, GLuint n);
3033
3034 static void
3035 unpack_uint_z_Z24_X8(const void *src, GLuint *dst, GLuint n)
3036 {
3037 /* only return Z, not stencil data */
3038 const GLuint *s = ((const GLuint *) src);
3039 GLuint i;
3040 for (i = 0; i < n; i++) {
3041 dst[i] = (s[i] & 0xffffff00) | (s[i] >> 24);
3042 }
3043 }
3044
3045 static void
3046 unpack_uint_z_X8_Z24(const void *src, GLuint *dst, GLuint n)
3047 {
3048 /* only return Z, not stencil data */
3049 const GLuint *s = ((const GLuint *) src);
3050 GLuint i;
3051 for (i = 0; i < n; i++) {
3052 dst[i] = (s[i] << 8) | ((s[i] >> 16) & 0xff);
3053 }
3054 }
3055
3056 static void
3057 unpack_uint_z_Z16(const void *src, GLuint *dst, GLuint n)
3058 {
3059 const GLushort *s = ((const GLushort *)src);
3060 GLuint i;
3061 for (i = 0; i < n; i++) {
3062 dst[i] = (s[i] << 16) | s[i];
3063 }
3064 }
3065
3066 static void
3067 unpack_uint_z_Z32(const void *src, GLuint *dst, GLuint n)
3068 {
3069 memcpy(dst, src, n * sizeof(GLuint));
3070 }
3071
3072 static void
3073 unpack_uint_z_Z32_FLOAT(const void *src, GLuint *dst, GLuint n)
3074 {
3075 const float *s = (const float *)src;
3076 GLuint i;
3077 for (i = 0; i < n; i++) {
3078 dst[i] = FLOAT_TO_UINT(CLAMP(s[i], 0.0F, 1.0F));
3079 }
3080 }
3081
3082 static void
3083 unpack_uint_z_Z32_FLOAT_X24S8(const void *src, GLuint *dst, GLuint n)
3084 {
3085 const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
3086 GLuint i;
3087
3088 for (i = 0; i < n; i++) {
3089 dst[i] = FLOAT_TO_UINT(CLAMP(s[i].z, 0.0F, 1.0F));
3090 }
3091 }
3092
3093
3094 /**
3095 * Unpack Z values.
3096 * The returned values will always be in the range [0, 0xffffffff].
3097 */
3098 void
3099 _mesa_unpack_uint_z_row(gl_format format, GLuint n,
3100 const void *src, GLuint *dst)
3101 {
3102 unpack_uint_z_func unpack;
3103 const GLubyte *srcPtr = (GLubyte *) src;
3104
3105 switch (format) {
3106 case MESA_FORMAT_Z24_S8:
3107 case MESA_FORMAT_Z24_X8:
3108 unpack = unpack_uint_z_Z24_X8;
3109 break;
3110 case MESA_FORMAT_S8_Z24:
3111 case MESA_FORMAT_X8_Z24:
3112 unpack = unpack_uint_z_X8_Z24;
3113 break;
3114 case MESA_FORMAT_Z16:
3115 unpack = unpack_uint_z_Z16;
3116 break;
3117 case MESA_FORMAT_Z32:
3118 unpack = unpack_uint_z_Z32;
3119 break;
3120 case MESA_FORMAT_Z32_FLOAT:
3121 unpack = unpack_uint_z_Z32_FLOAT;
3122 break;
3123 case MESA_FORMAT_Z32_FLOAT_X24S8:
3124 unpack = unpack_uint_z_Z32_FLOAT_X24S8;
3125 break;
3126 default:
3127 _mesa_problem(NULL, "bad format %s in _mesa_unpack_uint_z_row",
3128 _mesa_get_format_name(format));
3129 return;
3130 }
3131
3132 unpack(srcPtr, dst, n);
3133 }
3134
3135
3136 static void
3137 unpack_ubyte_s_S8(const void *src, GLubyte *dst, GLuint n)
3138 {
3139 memcpy(dst, src, n);
3140 }
3141
3142 static void
3143 unpack_ubyte_s_Z24_S8(const void *src, GLubyte *dst, GLuint n)
3144 {
3145 GLuint i;
3146 const GLuint *src32 = src;
3147
3148 for (i = 0; i < n; i++)
3149 dst[i] = src32[i] & 0xff;
3150 }
3151
3152 static void
3153 unpack_ubyte_s_S8_Z24(const void *src, GLubyte *dst, GLuint n)
3154 {
3155 GLuint i;
3156 const GLuint *src32 = src;
3157
3158 for (i = 0; i < n; i++)
3159 dst[i] = src32[i] >> 24;
3160 }
3161
3162 static void
3163 unpack_ubyte_s_Z32_FLOAT_X24S8(const void *src, GLubyte *dst, GLuint n)
3164 {
3165 GLuint i;
3166 const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
3167
3168 for (i = 0; i < n; i++)
3169 dst[i] = s[i].x24s8 & 0xff;
3170 }
3171
3172 void
3173 _mesa_unpack_ubyte_stencil_row(gl_format format, GLuint n,
3174 const void *src, GLubyte *dst)
3175 {
3176 switch (format) {
3177 case MESA_FORMAT_S8:
3178 unpack_ubyte_s_S8(src, dst, n);
3179 break;
3180 case MESA_FORMAT_Z24_S8:
3181 unpack_ubyte_s_Z24_S8(src, dst, n);
3182 break;
3183 case MESA_FORMAT_S8_Z24:
3184 unpack_ubyte_s_S8_Z24(src, dst, n);
3185 break;
3186 case MESA_FORMAT_Z32_FLOAT_X24S8:
3187 unpack_ubyte_s_Z32_FLOAT_X24S8(src, dst, n);
3188 break;
3189 default:
3190 _mesa_problem(NULL, "bad format %s in _mesa_unpack_ubyte_s_row",
3191 _mesa_get_format_name(format));
3192 return;
3193 }
3194 }
3195
3196 static void
3197 unpack_uint_24_8_depth_stencil_S8_Z24(const GLuint *src, GLuint *dst, GLuint n)
3198 {
3199 GLuint i;
3200
3201 for (i = 0; i < n; i++) {
3202 GLuint val = src[i];
3203 dst[i] = val >> 24 | val << 8;
3204 }
3205 }
3206
3207 static void
3208 unpack_uint_24_8_depth_stencil_Z24_S8(const GLuint *src, GLuint *dst, GLuint n)
3209 {
3210 memcpy(dst, src, n * 4);
3211 }
3212
3213 void
3214 _mesa_unpack_uint_24_8_depth_stencil_row(gl_format format, GLuint n,
3215 const void *src, GLuint *dst)
3216 {
3217 switch (format) {
3218 case MESA_FORMAT_Z24_S8:
3219 unpack_uint_24_8_depth_stencil_Z24_S8(src, dst, n);
3220 break;
3221 case MESA_FORMAT_S8_Z24:
3222 unpack_uint_24_8_depth_stencil_S8_Z24(src, dst, n);
3223 break;
3224 default:
3225 _mesa_problem(NULL,
3226 "bad format %s in _mesa_unpack_uint_24_8_depth_stencil_row",
3227 _mesa_get_format_name(format));
3228 return;
3229 }
3230 }