projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'llvm-cliptest-viewport'
[mesa.git] / src / mesa / main / texfetch_tmp.h
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.7
4 *
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
6 * Copyright (c) 2008-2009 VMware, Inc.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27 /**
28 * \file texfetch_tmp.h
29 * Texel fetch functions template.
30 *
31 * This template file is used by texfetch.c to generate texel fetch functions
32 * for 1-D, 2-D and 3-D texture images.
33 *
34 * It should be expanded by defining \p DIM as the number texture dimensions
35 * (1, 2 or 3). According to the value of \p DIM a series of macros is defined
36 * for the texel lookup in the gl_texture_image::Data.
37 *
38 * \author Gareth Hughes
39 * \author Brian Paul
40 */
41
42
43 #if DIM == 1
44
45 #define TEXEL_ADDR( type, image, i, j, k, size ) \
46 ((void) (j), (void) (k), ((type *)(image)->Data + (i) * (size)))
47
48 #define FETCH(x) fetch_texel_1d_##x
49
50 #elif DIM == 2
51
52 #define TEXEL_ADDR( type, image, i, j, k, size ) \
53 ((void) (k), \
54 ((type *)(image)->Data + ((image)->RowStride * (j) + (i)) * (size)))
55
56 #define FETCH(x) fetch_texel_2d_##x
57
58 #elif DIM == 3
59
60 #define TEXEL_ADDR( type, image, i, j, k, size ) \
61 ((type *)(image)->Data + ((image)->ImageOffsets[k] \
62 + (image)->RowStride * (j) + (i)) * (size))
63
64 #define FETCH(x) fetch_texel_3d_##x
65
66 #else
67 #error illegal number of texture dimensions
68 #endif
69
70
71 /* MESA_FORMAT_Z32 ***********************************************************/
72
73 /* Fetch depth texel from 1D, 2D or 3D 32-bit depth texture,
74 * returning 1 GLfloat.
75 * Note: no GLchan version of this function.
76 */
77 static void FETCH(f_z32)( const struct gl_texture_image *texImage,
78 GLint i, GLint j, GLint k, GLfloat *texel )
79 {
80 const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
81 texel[0] = src[0] * (1.0F / 0xffffffff);
82 }
83
84 #if DIM == 3
85 static void store_texel_z32(struct gl_texture_image *texImage,
86 GLint i, GLint j, GLint k, const void *texel)
87 {
88 const GLuint *depth = (const GLuint *) texel;
89 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
90 dst[0] = *depth;
91 }
92 #endif
93
94
95 /* MESA_FORMAT_Z16 ***********************************************************/
96
97 /* Fetch depth texel from 1D, 2D or 3D 16-bit depth texture,
98 * returning 1 GLfloat.
99 * Note: no GLchan version of this function.
100 */
101 static void FETCH(f_z16)(const struct gl_texture_image *texImage,
102 GLint i, GLint j, GLint k, GLfloat *texel )
103 {
104 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
105 texel[0] = src[0] * (1.0F / 65535.0F);
106 }
107
108 #if DIM == 3
109 static void store_texel_z16(struct gl_texture_image *texImage,
110 GLint i, GLint j, GLint k, const void *texel)
111 {
112 const GLushort *depth = (const GLushort *) texel;
113 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
114 dst[0] = *depth;
115 }
116 #endif
117
118
119 /* MESA_FORMAT_RGBA_F32 ******************************************************/
120
121 /* Fetch texel from 1D, 2D or 3D RGBA_FLOAT32 texture, returning 4 GLfloats.
122 */
123 static void FETCH(f_rgba_f32)( const struct gl_texture_image *texImage,
124 GLint i, GLint j, GLint k, GLfloat *texel )
125 {
126 const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 4);
127 texel[RCOMP] = src[0];
128 texel[GCOMP] = src[1];
129 texel[BCOMP] = src[2];
130 texel[ACOMP] = src[3];
131 }
132
133 #if DIM == 3
134 static void store_texel_rgba_f32(struct gl_texture_image *texImage,
135 GLint i, GLint j, GLint k, const void *texel)
136 {
137 const GLfloat *depth = (const GLfloat *) texel;
138 GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
139 dst[0] = depth[RCOMP];
140 dst[1] = depth[GCOMP];
141 dst[2] = depth[BCOMP];
142 dst[3] = depth[ACOMP];
143 }
144 #endif
145
146
147 /* MESA_FORMAT_RGBA_F16 ******************************************************/
148
149 /* Fetch texel from 1D, 2D or 3D RGBA_FLOAT16 texture,
150 * returning 4 GLfloats.
151 */
152 static void FETCH(f_rgba_f16)( const struct gl_texture_image *texImage,
153 GLint i, GLint j, GLint k, GLfloat *texel )
154 {
155 const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 4);
156 texel[RCOMP] = _mesa_half_to_float(src[0]);
157 texel[GCOMP] = _mesa_half_to_float(src[1]);
158 texel[BCOMP] = _mesa_half_to_float(src[2]);
159 texel[ACOMP] = _mesa_half_to_float(src[3]);
160 }
161
162 #if DIM == 3
163 static void store_texel_rgba_f16(struct gl_texture_image *texImage,
164 GLint i, GLint j, GLint k, const void *texel)
165 {
166 const GLfloat *depth = (const GLfloat *) texel;
167 GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
168 dst[0] = _mesa_float_to_half(*depth);
169 }
170 #endif
171
172 /* MESA_FORMAT_RGB_F32 *******************************************************/
173
174 /* Fetch texel from 1D, 2D or 3D RGB_FLOAT32 texture,
175 * returning 4 GLfloats.
176 */
177 static void FETCH(f_rgb_f32)( const struct gl_texture_image *texImage,
178 GLint i, GLint j, GLint k, GLfloat *texel )
179 {
180 const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 3);
181 texel[RCOMP] = src[0];
182 texel[GCOMP] = src[1];
183 texel[BCOMP] = src[2];
184 texel[ACOMP] = 1.0F;
185 }
186
187 #if DIM == 3
188 static void store_texel_rgb_f32(struct gl_texture_image *texImage,
189 GLint i, GLint j, GLint k, const void *texel)
190 {
191 const GLfloat *depth = (const GLfloat *) texel;
192 GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
193 dst[0] = *depth;
194 }
195 #endif
196
197
198 /* MESA_FORMAT_RGB_F16 *******************************************************/
199
200 /* Fetch texel from 1D, 2D or 3D RGB_FLOAT16 texture,
201 * returning 4 GLfloats.
202 */
203 static void FETCH(f_rgb_f16)( const struct gl_texture_image *texImage,
204 GLint i, GLint j, GLint k, GLfloat *texel )
205 {
206 const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 3);
207 texel[RCOMP] = _mesa_half_to_float(src[0]);
208 texel[GCOMP] = _mesa_half_to_float(src[1]);
209 texel[BCOMP] = _mesa_half_to_float(src[2]);
210 texel[ACOMP] = 1.0F;
211 }
212
213 #if DIM == 3
214 static void store_texel_rgb_f16(struct gl_texture_image *texImage,
215 GLint i, GLint j, GLint k, const void *texel)
216 {
217 const GLfloat *depth = (const GLfloat *) texel;
218 GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
219 dst[0] = _mesa_float_to_half(*depth);
220 }
221 #endif
222
223
224 /* MESA_FORMAT_ALPHA_F32 *****************************************************/
225
226 /* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT32 texture,
227 * returning 4 GLfloats.
228 */
229 static void FETCH(f_alpha_f32)( const struct gl_texture_image *texImage,
230 GLint i, GLint j, GLint k, GLfloat *texel )
231 {
232 const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
233 texel[RCOMP] =
234 texel[GCOMP] =
235 texel[BCOMP] = 0.0F;
236 texel[ACOMP] = src[0];
237 }
238
239 #if DIM == 3
240 static void store_texel_alpha_f32(struct gl_texture_image *texImage,
241 GLint i, GLint j, GLint k, const void *texel)
242 {
243 const GLfloat *rgba = (const GLfloat *) texel;
244 GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
245 dst[0] = rgba[ACOMP];
246 }
247 #endif
248
249
250 /* MESA_FORMAT_ALPHA_F32 *****************************************************/
251
252 /* Fetch texel from 1D, 2D or 3D ALPHA_FLOAT16 texture,
253 * returning 4 GLfloats.
254 */
255 static void FETCH(f_alpha_f16)( const struct gl_texture_image *texImage,
256 GLint i, GLint j, GLint k, GLfloat *texel )
257 {
258 const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
259 texel[RCOMP] =
260 texel[GCOMP] =
261 texel[BCOMP] = 0.0F;
262 texel[ACOMP] = _mesa_half_to_float(src[0]);
263 }
264
265 #if DIM == 3
266 static void store_texel_alpha_f16(struct gl_texture_image *texImage,
267 GLint i, GLint j, GLint k, const void *texel)
268 {
269 const GLfloat *rgba = (const GLfloat *) texel;
270 GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
271 dst[0] = _mesa_float_to_half(rgba[ACOMP]);
272 }
273 #endif
274
275
276 /* MESA_FORMAT_LUMINANCE_F32 *************************************************/
277
278 /* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT32 texture,
279 * returning 4 GLfloats.
280 */
281 static void FETCH(f_luminance_f32)( const struct gl_texture_image *texImage,
282 GLint i, GLint j, GLint k, GLfloat *texel )
283 {
284 const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
285 texel[RCOMP] =
286 texel[GCOMP] =
287 texel[BCOMP] = src[0];
288 texel[ACOMP] = 1.0F;
289 }
290
291 #if DIM == 3
292 static void store_texel_luminance_f32(struct gl_texture_image *texImage,
293 GLint i, GLint j, GLint k, const void *texel)
294 {
295 const GLfloat *rgba = (const GLfloat *) texel;
296 GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
297 dst[0] = rgba[RCOMP];
298 }
299 #endif
300
301
302 /* MESA_FORMAT_LUMINANCE_F16 *************************************************/
303
304 /* Fetch texel from 1D, 2D or 3D LUMINANCE_FLOAT16 texture,
305 * returning 4 GLfloats.
306 */
307 static void FETCH(f_luminance_f16)( const struct gl_texture_image *texImage,
308 GLint i, GLint j, GLint k, GLfloat *texel )
309 {
310 const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
311 texel[RCOMP] =
312 texel[GCOMP] =
313 texel[BCOMP] = _mesa_half_to_float(src[0]);
314 texel[ACOMP] = 1.0F;
315 }
316
317 #if DIM == 3
318 static void store_texel_luminance_f16(struct gl_texture_image *texImage,
319 GLint i, GLint j, GLint k, const void *texel)
320 {
321 const GLfloat *rgba = (const GLfloat *) texel;
322 GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
323 dst[0] = _mesa_float_to_half(rgba[RCOMP]);
324 }
325 #endif
326
327
328 /* MESA_FORMAT_LUMINANCE_ALPHA_F32 *******************************************/
329
330 /* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT32 texture,
331 * returning 4 GLfloats.
332 */
333 static void FETCH(f_luminance_alpha_f32)( const struct gl_texture_image *texImage,
334 GLint i, GLint j, GLint k, GLfloat *texel )
335 {
336 const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
337 texel[RCOMP] =
338 texel[GCOMP] =
339 texel[BCOMP] = src[0];
340 texel[ACOMP] = src[1];
341 }
342
343 #if DIM == 3
344 static void store_texel_luminance_alpha_f32(struct gl_texture_image *texImage,
345 GLint i, GLint j, GLint k, const void *texel)
346 {
347 const GLfloat *rgba = (const GLfloat *) texel;
348 GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 2);
349 dst[0] = rgba[RCOMP];
350 dst[1] = rgba[ACOMP];
351 }
352 #endif
353
354
355 /* MESA_FORMAT_LUMINANCE_ALPHA_F16 *******************************************/
356
357 /* Fetch texel from 1D, 2D or 3D LUMINANCE_ALPHA_FLOAT16 texture,
358 * returning 4 GLfloats.
359 */
360 static void FETCH(f_luminance_alpha_f16)( const struct gl_texture_image *texImage,
361 GLint i, GLint j, GLint k, GLfloat *texel )
362 {
363 const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
364 texel[RCOMP] =
365 texel[GCOMP] =
366 texel[BCOMP] = _mesa_half_to_float(src[0]);
367 texel[ACOMP] = _mesa_half_to_float(src[1]);
368 }
369
370 #if DIM == 3
371 static void store_texel_luminance_alpha_f16(struct gl_texture_image *texImage,
372 GLint i, GLint j, GLint k, const void *texel)
373 {
374 const GLfloat *rgba = (const GLfloat *) texel;
375 GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 2);
376 dst[0] = _mesa_float_to_half(rgba[RCOMP]);
377 dst[1] = _mesa_float_to_half(rgba[ACOMP]);
378 }
379 #endif
380
381
382 /* MESA_FORMAT_INTENSITY_F32 *************************************************/
383
384 /* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT32 texture,
385 * returning 4 GLfloats.
386 */
387 static void FETCH(f_intensity_f32)( const struct gl_texture_image *texImage,
388 GLint i, GLint j, GLint k, GLfloat *texel )
389 {
390 const GLfloat *src = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
391 texel[RCOMP] =
392 texel[GCOMP] =
393 texel[BCOMP] =
394 texel[ACOMP] = src[0];
395 }
396
397 #if DIM == 3
398 static void store_texel_intensity_f32(struct gl_texture_image *texImage,
399 GLint i, GLint j, GLint k, const void *texel)
400 {
401 const GLfloat *rgba = (const GLfloat *) texel;
402 GLfloat *dst = TEXEL_ADDR(GLfloat, texImage, i, j, k, 1);
403 dst[0] = rgba[RCOMP];
404 }
405 #endif
406
407
408 /* MESA_FORMAT_INTENSITY_F16 *************************************************/
409
410 /* Fetch texel from 1D, 2D or 3D INTENSITY_FLOAT16 texture,
411 * returning 4 GLfloats.
412 */
413 static void FETCH(f_intensity_f16)( const struct gl_texture_image *texImage,
414 GLint i, GLint j, GLint k, GLfloat *texel )
415 {
416 const GLhalfARB *src = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
417 texel[RCOMP] =
418 texel[GCOMP] =
419 texel[BCOMP] =
420 texel[ACOMP] = _mesa_half_to_float(src[0]);
421 }
422
423 #if DIM == 3
424 static void store_texel_intensity_f16(struct gl_texture_image *texImage,
425 GLint i, GLint j, GLint k, const void *texel)
426 {
427 const GLfloat *rgba = (const GLfloat *) texel;
428 GLhalfARB *dst = TEXEL_ADDR(GLhalfARB, texImage, i, j, k, 1);
429 dst[0] = _mesa_float_to_half(rgba[RCOMP]);
430 }
431 #endif
432
433
434
435
436 /*
437 * Begin Hardware formats
438 */
439
440 /* MESA_FORMAT_RGBA8888 ******************************************************/
441
442 /* Fetch texel from 1D, 2D or 3D rgba8888 texture, return 4 GLfloats */
443 static void FETCH(f_rgba8888)( const struct gl_texture_image *texImage,
444 GLint i, GLint j, GLint k, GLfloat *texel )
445 {
446 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
447 texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 24) );
448 texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
449 texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff );
450 texel[ACOMP] = UBYTE_TO_FLOAT( (s ) & 0xff );
451 }
452
453
454
455 #if DIM == 3
456 static void store_texel_rgba8888(struct gl_texture_image *texImage,
457 GLint i, GLint j, GLint k, const void *texel)
458 {
459 const GLubyte *rgba = (const GLubyte *) texel;
460 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
461 *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
462 }
463 #endif
464
465
466 /* MESA_FORMAT_RGBA888_REV ***************************************************/
467
468 /* Fetch texel from 1D, 2D or 3D abgr8888 texture, return 4 GLchans */
469 static void FETCH(f_rgba8888_rev)( const struct gl_texture_image *texImage,
470 GLint i, GLint j, GLint k, GLfloat *texel )
471 {
472 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
473 texel[RCOMP] = UBYTE_TO_FLOAT( (s ) & 0xff );
474 texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff );
475 texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
476 texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) );
477 }
478
479 #if DIM == 3
480 static void store_texel_rgba8888_rev(struct gl_texture_image *texImage,
481 GLint i, GLint j, GLint k, const void *texel)
482 {
483 const GLubyte *rgba = (const GLubyte *) texel;
484 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
485 *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
486 }
487 #endif
488
489
490 /* MESA_FORMAT_ARGB8888 ******************************************************/
491
492 /* Fetch texel from 1D, 2D or 3D argb8888 texture, return 4 GLchans */
493 static void FETCH(f_argb8888)( const struct gl_texture_image *texImage,
494 GLint i, GLint j, GLint k, GLfloat *texel )
495 {
496 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
497 texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
498 texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff );
499 texel[BCOMP] = UBYTE_TO_FLOAT( (s ) & 0xff );
500 texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) );
501 }
502
503 #if DIM == 3
504 static void store_texel_argb8888(struct gl_texture_image *texImage,
505 GLint i, GLint j, GLint k, const void *texel)
506 {
507 const GLubyte *rgba = (const GLubyte *) texel;
508 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
509 *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
510 }
511 #endif
512
513
514 /* MESA_FORMAT_ARGB8888_REV **************************************************/
515
516 /* Fetch texel from 1D, 2D or 3D argb8888_rev texture, return 4 GLfloats */
517 static void FETCH(f_argb8888_rev)( const struct gl_texture_image *texImage,
518 GLint i, GLint j, GLint k, GLfloat *texel )
519 {
520 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
521 texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff );
522 texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
523 texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24) );
524 texel[ACOMP] = UBYTE_TO_FLOAT( (s ) & 0xff );
525 }
526
527 #if DIM == 3
528 static void store_texel_argb8888_rev(struct gl_texture_image *texImage,
529 GLint i, GLint j, GLint k, const void *texel)
530 {
531 const GLubyte *rgba = (const GLubyte *) texel;
532 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
533 *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], rgba[ACOMP]);
534 }
535 #endif
536
537
538 /* MESA_FORMAT_XRGB8888 ******************************************************/
539
540 /* Fetch texel from 1D, 2D or 3D xrgb8888 texture, return 4 GLchans */
541 static void FETCH(f_xrgb8888)( const struct gl_texture_image *texImage,
542 GLint i, GLint j, GLint k, GLfloat *texel )
543 {
544 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
545 texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
546 texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff );
547 texel[BCOMP] = UBYTE_TO_FLOAT( (s ) & 0xff );
548 texel[ACOMP] = 1.0f;
549 }
550
551 #if DIM == 3
552 static void store_texel_xrgb8888(struct gl_texture_image *texImage,
553 GLint i, GLint j, GLint k, const void *texel)
554 {
555 const GLubyte *rgba = (const GLubyte *) texel;
556 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
557 *dst = PACK_COLOR_8888(0xff, rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
558 }
559 #endif
560
561
562 /* MESA_FORMAT_XRGB8888_REV **************************************************/
563
564 /* Fetch texel from 1D, 2D or 3D xrgb8888_rev texture, return 4 GLfloats */
565 static void FETCH(f_xrgb8888_rev)( const struct gl_texture_image *texImage,
566 GLint i, GLint j, GLint k, GLfloat *texel )
567 {
568 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
569 texel[RCOMP] = UBYTE_TO_FLOAT( (s >> 8) & 0xff );
570 texel[GCOMP] = UBYTE_TO_FLOAT( (s >> 16) & 0xff );
571 texel[BCOMP] = UBYTE_TO_FLOAT( (s >> 24) );
572 texel[ACOMP] = 1.0f;
573 }
574
575 #if DIM == 3
576 static void store_texel_xrgb8888_rev(struct gl_texture_image *texImage,
577 GLint i, GLint j, GLint k, const void *texel)
578 {
579 const GLubyte *rgba = (const GLubyte *) texel;
580 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
581 *dst = PACK_COLOR_8888(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP], 0xff);
582 }
583 #endif
584
585
586 /* MESA_FORMAT_RGB888 ********************************************************/
587
588 /* Fetch texel from 1D, 2D or 3D rgb888 texture, return 4 GLchans */
589 static void FETCH(f_rgb888)( const struct gl_texture_image *texImage,
590 GLint i, GLint j, GLint k, GLfloat *texel )
591 {
592 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
593 texel[RCOMP] = UBYTE_TO_FLOAT( src[2] );
594 texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
595 texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
596 texel[ACOMP] = 1.0F;
597 }
598
599 #if DIM == 3
600 static void store_texel_rgb888(struct gl_texture_image *texImage,
601 GLint i, GLint j, GLint k, const void *texel)
602 {
603 const GLubyte *rgba = (const GLubyte *) texel;
604 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
605 dst[0] = rgba[BCOMP];
606 dst[1] = rgba[GCOMP];
607 dst[2] = rgba[RCOMP];
608 }
609 #endif
610
611
612 /* MESA_FORMAT_BGR888 ********************************************************/
613
614 /* Fetch texel from 1D, 2D or 3D bgr888 texture, return 4 GLchans */
615 static void FETCH(f_bgr888)( const struct gl_texture_image *texImage,
616 GLint i, GLint j, GLint k, GLfloat *texel )
617 {
618 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
619 texel[RCOMP] = UBYTE_TO_FLOAT( src[0] );
620 texel[GCOMP] = UBYTE_TO_FLOAT( src[1] );
621 texel[BCOMP] = UBYTE_TO_FLOAT( src[2] );
622 texel[ACOMP] = 1.0F;
623 }
624
625 #if DIM == 3
626 static void store_texel_bgr888(struct gl_texture_image *texImage,
627 GLint i, GLint j, GLint k, const void *texel)
628 {
629 const GLubyte *rgba = (const GLubyte *) texel;
630 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
631 dst[0] = rgba[RCOMP];
632 dst[1] = rgba[GCOMP];
633 dst[2] = rgba[BCOMP];
634 }
635 #endif
636
637
638 /* use color expansion like (g << 2) | (g >> 4) (does somewhat random rounding)
639 instead of slow (g << 2) * 255 / 252 (always rounds down) */
640
641 /* MESA_FORMAT_RGB565 ********************************************************/
642
643 /* Fetch texel from 1D, 2D or 3D rgb565 texture, return 4 GLchans */
644 static void FETCH(f_rgb565)( const struct gl_texture_image *texImage,
645 GLint i, GLint j, GLint k, GLfloat *texel )
646 {
647 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
648 const GLushort s = *src;
649 texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
650 texel[GCOMP] = ((s >> 5 ) & 0x3f) * (1.0F / 63.0F);
651 texel[BCOMP] = ((s ) & 0x1f) * (1.0F / 31.0F);
652 texel[ACOMP] = 1.0F;
653 }
654
655 #if DIM == 3
656 static void store_texel_rgb565(struct gl_texture_image *texImage,
657 GLint i, GLint j, GLint k, const void *texel)
658 {
659 const GLubyte *rgba = (const GLubyte *) texel;
660 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
661 *dst = PACK_COLOR_565(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
662 }
663 #endif
664
665
666 /* MESA_FORMAT_RGB565_REV ****************************************************/
667
668 /* Fetch texel from 1D, 2D or 3D rgb565_rev texture, return 4 GLchans */
669 static void FETCH(f_rgb565_rev)( const struct gl_texture_image *texImage,
670 GLint i, GLint j, GLint k, GLfloat *texel )
671 {
672 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
673 const GLushort s = (*src >> 8) | (*src << 8); /* byte swap */
674 texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 8) & 0xf8) | ((s >> 13) & 0x7) );
675 texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 3) & 0xfc) | ((s >> 9) & 0x3) );
676 texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >> 2) & 0x7) );
677 texel[ACOMP] = 1.0F;
678 }
679
680 #if DIM == 3
681 static void store_texel_rgb565_rev(struct gl_texture_image *texImage,
682 GLint i, GLint j, GLint k, const void *texel)
683 {
684 const GLubyte *rgba = (const GLubyte *) texel;
685 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
686 *dst = PACK_COLOR_565(rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
687 }
688 #endif
689
690
691 /* MESA_FORMAT_ARGB4444 ******************************************************/
692
693 /* Fetch texel from 1D, 2D or 3D argb444 texture, return 4 GLchans */
694 static void FETCH(f_argb4444)( const struct gl_texture_image *texImage,
695 GLint i, GLint j, GLint k, GLfloat *texel )
696 {
697 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
698 const GLushort s = *src;
699 texel[RCOMP] = ((s >> 8) & 0xf) * (1.0F / 15.0F);
700 texel[GCOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F);
701 texel[BCOMP] = ((s ) & 0xf) * (1.0F / 15.0F);
702 texel[ACOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
703 }
704
705 #if DIM == 3
706 static void store_texel_argb4444(struct gl_texture_image *texImage,
707 GLint i, GLint j, GLint k, const void *texel)
708 {
709 const GLubyte *rgba = (const GLubyte *) texel;
710 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
711 *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
712 }
713 #endif
714
715
716 /* MESA_FORMAT_ARGB4444_REV **************************************************/
717
718 /* Fetch texel from 1D, 2D or 3D argb4444_rev texture, return 4 GLchans */
719 static void FETCH(f_argb4444_rev)( const struct gl_texture_image *texImage,
720 GLint i, GLint j, GLint k, GLfloat *texel )
721 {
722 const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
723 texel[RCOMP] = ((s ) & 0xf) * (1.0F / 15.0F);
724 texel[GCOMP] = ((s >> 12) & 0xf) * (1.0F / 15.0F);
725 texel[BCOMP] = ((s >> 8) & 0xf) * (1.0F / 15.0F);
726 texel[ACOMP] = ((s >> 4) & 0xf) * (1.0F / 15.0F);
727 }
728
729 #if DIM == 3
730 static void store_texel_argb4444_rev(struct gl_texture_image *texImage,
731 GLint i, GLint j, GLint k, const void *texel)
732 {
733 const GLubyte *rgba = (const GLubyte *) texel;
734 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
735 *dst = PACK_COLOR_4444(rgba[ACOMP], rgba[BCOMP], rgba[GCOMP], rgba[RCOMP]);
736 }
737 #endif
738
739 /* MESA_FORMAT_RGBA5551 ******************************************************/
740
741 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
742 static void FETCH(f_rgba5551)( const struct gl_texture_image *texImage,
743 GLint i, GLint j, GLint k, GLfloat *texel )
744 {
745 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
746 const GLushort s = *src;
747 texel[RCOMP] = ((s >> 11) & 0x1f) * (1.0F / 31.0F);
748 texel[GCOMP] = ((s >> 6) & 0x1f) * (1.0F / 31.0F);
749 texel[BCOMP] = ((s >> 1) & 0x1f) * (1.0F / 31.0F);
750 texel[ACOMP] = ((s ) & 0x01) * 1.0F;
751 }
752
753 #if DIM == 3
754 static void store_texel_rgba5551(struct gl_texture_image *texImage,
755 GLint i, GLint j, GLint k, const void *texel)
756 {
757 const GLubyte *rgba = (const GLubyte *) texel;
758 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
759 *dst = PACK_COLOR_5551(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
760 }
761 #endif
762
763 /* MESA_FORMAT_ARGB1555 ******************************************************/
764
765 /* Fetch texel from 1D, 2D or 3D argb1555 texture, return 4 GLchans */
766 static void FETCH(f_argb1555)( const struct gl_texture_image *texImage,
767 GLint i, GLint j, GLint k, GLfloat *texel )
768 {
769 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
770 const GLushort s = *src;
771 texel[RCOMP] = ((s >> 10) & 0x1f) * (1.0F / 31.0F);
772 texel[GCOMP] = ((s >> 5) & 0x1f) * (1.0F / 31.0F);
773 texel[BCOMP] = ((s >> 0) & 0x1f) * (1.0F / 31.0F);
774 texel[ACOMP] = ((s >> 15) & 0x01) * 1.0F;
775 }
776
777 #if DIM == 3
778 static void store_texel_argb1555(struct gl_texture_image *texImage,
779 GLint i, GLint j, GLint k, const void *texel)
780 {
781 const GLubyte *rgba = (const GLubyte *) texel;
782 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
783 *dst = PACK_COLOR_1555(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
784 }
785 #endif
786
787
788 /* MESA_FORMAT_ARGB1555_REV **************************************************/
789
790 /* Fetch texel from 1D, 2D or 3D argb1555_rev texture, return 4 GLchans */
791 static void FETCH(f_argb1555_rev)( const struct gl_texture_image *texImage,
792 GLint i, GLint j, GLint k, GLfloat *texel )
793 {
794 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
795 const GLushort s = (*src << 8) | (*src >> 8); /* byteswap */
796 texel[RCOMP] = UBYTE_TO_FLOAT( ((s >> 7) & 0xf8) | ((s >> 12) & 0x7) );
797 texel[GCOMP] = UBYTE_TO_FLOAT( ((s >> 2) & 0xf8) | ((s >> 7) & 0x7) );
798 texel[BCOMP] = UBYTE_TO_FLOAT( ((s << 3) & 0xf8) | ((s >> 2) & 0x7) );
799 texel[ACOMP] = UBYTE_TO_FLOAT( ((s >> 15) & 0x01) * 255 );
800 }
801
802 #if DIM == 3
803 static void store_texel_argb1555_rev(struct gl_texture_image *texImage,
804 GLint i, GLint j, GLint k, const void *texel)
805 {
806 const GLubyte *rgba = (const GLubyte *) texel;
807 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
808 *dst = PACK_COLOR_1555_REV(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
809 }
810 #endif
811
812
813 /* MESA_FORMAT_RG88 **********************************************************/
814
815 /* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */
816 static void FETCH(f_rg88)( const struct gl_texture_image *texImage,
817 GLint i, GLint j, GLint k, GLfloat *texel )
818 {
819 const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
820 texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );
821 texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );
822 texel[BCOMP] = 0.0;
823 texel[ACOMP] = 1.0;
824 }
825
826 #if DIM == 3
827 static void store_texel_rg88(struct gl_texture_image *texImage,
828 GLint i, GLint j, GLint k, const void *texel)
829 {
830 const GLubyte *rgba = (const GLubyte *) texel;
831 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
832 *dst = PACK_COLOR_88(rgba[RCOMP], rgba[GCOMP]);
833 }
834 #endif
835
836
837 /* MESA_FORMAT_RG88_REV ******************************************************/
838
839 /* Fetch texel from 1D, 2D or 3D rg88_rev texture, return 4 GLchans */
840 static void FETCH(f_rg88_rev)( const struct gl_texture_image *texImage,
841 GLint i, GLint j, GLint k, GLfloat *texel )
842 {
843 const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
844 texel[RCOMP] = UBYTE_TO_FLOAT( s & 0xff );
845 texel[GCOMP] = UBYTE_TO_FLOAT( s >> 8 );
846 texel[BCOMP] = 0.0;
847 texel[ACOMP] = 1.0;
848 }
849
850 #if DIM == 3
851 static void store_texel_rg88_rev(struct gl_texture_image *texImage,
852 GLint i, GLint j, GLint k, const void *texel)
853 {
854 const GLubyte *rgba = (const GLubyte *) texel;
855 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
856 *dst = PACK_COLOR_88(rgba[GCOMP], rgba[RCOMP]);
857 }
858 #endif
859
860
861 /* MESA_FORMAT_AL88 **********************************************************/
862
863 /* Fetch texel from 1D, 2D or 3D al88 texture, return 4 GLchans */
864 static void FETCH(f_al88)( const struct gl_texture_image *texImage,
865 GLint i, GLint j, GLint k, GLfloat *texel )
866 {
867 const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
868 texel[RCOMP] =
869 texel[GCOMP] =
870 texel[BCOMP] = UBYTE_TO_FLOAT( s & 0xff );
871 texel[ACOMP] = UBYTE_TO_FLOAT( s >> 8 );
872 }
873
874 #if DIM == 3
875 static void store_texel_al88(struct gl_texture_image *texImage,
876 GLint i, GLint j, GLint k, const void *texel)
877 {
878 const GLubyte *rgba = (const GLubyte *) texel;
879 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
880 *dst = PACK_COLOR_88(rgba[ACOMP], rgba[RCOMP]);
881 }
882 #endif
883
884
885 /* MESA_FORMAT_R8 ************************************************************/
886
887 /* Fetch texel from 1D, 2D or 3D rg88 texture, return 4 GLchans */
888 static void FETCH(f_r8)(const struct gl_texture_image *texImage,
889 GLint i, GLint j, GLint k, GLfloat *texel)
890 {
891 const GLubyte s = *TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
892 texel[RCOMP] = UBYTE_TO_FLOAT(s);
893 texel[GCOMP] = 0.0;
894 texel[BCOMP] = 0.0;
895 texel[ACOMP] = 1.0;
896 }
897
898 #if DIM == 3
899 static void store_texel_r8(struct gl_texture_image *texImage,
900 GLint i, GLint j, GLint k, const void *texel)
901 {
902 const GLubyte *rgba = (const GLubyte *) texel;
903 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
904 *dst = rgba[RCOMP];
905 }
906 #endif
907
908
909 /* MESA_FORMAT_R16 ***********************************************************/
910
911 /* Fetch texel from 1D, 2D or 3D r16 texture, return 4 GLchans */
912 static void FETCH(f_r16)(const struct gl_texture_image *texImage,
913 GLint i, GLint j, GLint k, GLfloat *texel)
914 {
915 const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
916 texel[RCOMP] = USHORT_TO_FLOAT(s);
917 texel[GCOMP] = 0.0;
918 texel[BCOMP] = 0.0;
919 texel[ACOMP] = 1.0;
920 }
921
922 #if DIM == 3
923 static void store_texel_r16(struct gl_texture_image *texImage,
924 GLint i, GLint j, GLint k, const void *texel)
925 {
926 const GLushort *rgba = (const GLushort *) texel;
927 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
928 *dst = rgba[RCOMP];
929 }
930 #endif
931
932
933 /* MESA_FORMAT_AL88_REV ******************************************************/
934
935 /* Fetch texel from 1D, 2D or 3D al88_rev texture, return 4 GLchans */
936 static void FETCH(f_al88_rev)( const struct gl_texture_image *texImage,
937 GLint i, GLint j, GLint k, GLfloat *texel )
938 {
939 const GLushort s = *TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
940 texel[RCOMP] =
941 texel[GCOMP] =
942 texel[BCOMP] = UBYTE_TO_FLOAT( s >> 8 );
943 texel[ACOMP] = UBYTE_TO_FLOAT( s & 0xff );
944 }
945
946 #if DIM == 3
947 static void store_texel_al88_rev(struct gl_texture_image *texImage,
948 GLint i, GLint j, GLint k, const void *texel)
949 {
950 const GLubyte *rgba = (const GLubyte *) texel;
951 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
952 *dst = PACK_COLOR_88(rgba[RCOMP], rgba[ACOMP]);
953 }
954 #endif
955
956
957 /* MESA_FORMAT_RG1616 ********************************************************/
958
959 /* Fetch texel from 1D, 2D or 3D rg1616 texture, return 4 GLchans */
960 static void FETCH(f_rg1616)( const struct gl_texture_image *texImage,
961 GLint i, GLint j, GLint k, GLfloat *texel )
962 {
963 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
964 texel[RCOMP] = USHORT_TO_FLOAT( s & 0xffff );
965 texel[GCOMP] = USHORT_TO_FLOAT( s >> 16 );
966 texel[BCOMP] = 0.0;
967 texel[ACOMP] = 1.0;
968 }
969
970 #if DIM == 3
971 static void store_texel_rg1616(struct gl_texture_image *texImage,
972 GLint i, GLint j, GLint k, const void *texel)
973 {
974 const GLubyte *rgba = (const GLubyte *) texel;
975 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
976 *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[GCOMP]);
977 }
978 #endif
979
980
981 /* MESA_FORMAT_RG1616_REV ****************************************************/
982
983 /* Fetch texel from 1D, 2D or 3D rg1616_rev texture, return 4 GLchans */
984 static void FETCH(f_rg1616_rev)( const struct gl_texture_image *texImage,
985 GLint i, GLint j, GLint k, GLfloat *texel )
986 {
987 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
988 texel[RCOMP] = USHORT_TO_FLOAT( s >> 16 );
989 texel[GCOMP] = USHORT_TO_FLOAT( s & 0xffff );
990 texel[BCOMP] = 0.0;
991 texel[ACOMP] = 1.0;
992 }
993
994 #if DIM == 3
995 static void store_texel_rg1616_rev(struct gl_texture_image *texImage,
996 GLint i, GLint j, GLint k, const void *texel)
997 {
998 const GLubyte *rgba = (const GLubyte *) texel;
999 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 1);
1000 *dst = PACK_COLOR_1616(rgba[GCOMP], rgba[RCOMP]);
1001 }
1002 #endif
1003
1004
1005 /* MESA_FORMAT_AL1616 ********************************************************/
1006
1007 /* Fetch texel from 1D, 2D or 3D al1616 texture, return 4 GLchans */
1008 static void FETCH(f_al1616)( const struct gl_texture_image *texImage,
1009 GLint i, GLint j, GLint k, GLfloat *texel )
1010 {
1011 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1012 texel[RCOMP] =
1013 texel[GCOMP] =
1014 texel[BCOMP] = USHORT_TO_FLOAT( s & 0xffff );
1015 texel[ACOMP] = USHORT_TO_FLOAT( s >> 16 );
1016 }
1017
1018 #if DIM == 3
1019 static void store_texel_al1616(struct gl_texture_image *texImage,
1020 GLint i, GLint j, GLint k, const void *texel)
1021 {
1022 const GLushort *rgba = (const GLushort *) texel;
1023 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1024 *dst = PACK_COLOR_1616(rgba[ACOMP], rgba[RCOMP]);
1025 }
1026 #endif
1027
1028
1029 /* MESA_FORMAT_AL1616_REV ****************************************************/
1030
1031 /* Fetch texel from 1D, 2D or 3D al1616_rev texture, return 4 GLchans */
1032 static void FETCH(f_al1616_rev)( const struct gl_texture_image *texImage,
1033 GLint i, GLint j, GLint k, GLfloat *texel )
1034 {
1035 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1036 texel[RCOMP] =
1037 texel[GCOMP] =
1038 texel[BCOMP] = USHORT_TO_FLOAT( s >> 16 );
1039 texel[ACOMP] = USHORT_TO_FLOAT( s & 0xffff );
1040 }
1041
1042 #if DIM == 3
1043 static void store_texel_al1616_rev(struct gl_texture_image *texImage,
1044 GLint i, GLint j, GLint k, const void *texel)
1045 {
1046 const GLushort *rgba = (const GLushort *) texel;
1047 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1048 *dst = PACK_COLOR_1616(rgba[RCOMP], rgba[ACOMP]);
1049 }
1050 #endif
1051
1052
1053 /* MESA_FORMAT_RGB332 ********************************************************/
1054
1055 /* Fetch texel from 1D, 2D or 3D rgb332 texture, return 4 GLchans */
1056 static void FETCH(f_rgb332)( const struct gl_texture_image *texImage,
1057 GLint i, GLint j, GLint k, GLfloat *texel )
1058 {
1059 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1060 const GLubyte s = *src;
1061 texel[RCOMP] = ((s >> 5) & 0x7) * (1.0F / 7.0F);
1062 texel[GCOMP] = ((s >> 2) & 0x7) * (1.0F / 7.0F);
1063 texel[BCOMP] = ((s ) & 0x3) * (1.0F / 3.0F);
1064 texel[ACOMP] = 1.0F;
1065 }
1066
1067 #if DIM == 3
1068 static void store_texel_rgb332(struct gl_texture_image *texImage,
1069 GLint i, GLint j, GLint k, const void *texel)
1070 {
1071 const GLubyte *rgba = (const GLubyte *) texel;
1072 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1073 *dst = PACK_COLOR_332(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
1074 }
1075 #endif
1076
1077
1078 /* MESA_FORMAT_A8 ************************************************************/
1079
1080 /* Fetch texel from 1D, 2D or 3D a8 texture, return 4 GLchans */
1081 static void FETCH(f_a8)( const struct gl_texture_image *texImage,
1082 GLint i, GLint j, GLint k, GLfloat *texel )
1083 {
1084 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1085 texel[RCOMP] =
1086 texel[GCOMP] =
1087 texel[BCOMP] = 0.0F;
1088 texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
1089 }
1090
1091 #if DIM == 3
1092 static void store_texel_a8(struct gl_texture_image *texImage,
1093 GLint i, GLint j, GLint k, const void *texel)
1094 {
1095 const GLubyte *rgba = (const GLubyte *) texel;
1096 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1097 *dst = rgba[ACOMP];
1098 }
1099 #endif
1100
1101
1102 /* MESA_FORMAT_L8 ************************************************************/
1103
1104 /* Fetch texel from 1D, 2D or 3D l8 texture, return 4 GLchans */
1105 static void FETCH(f_l8)( const struct gl_texture_image *texImage,
1106 GLint i, GLint j, GLint k, GLfloat *texel )
1107 {
1108 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1109 texel[RCOMP] =
1110 texel[GCOMP] =
1111 texel[BCOMP] = UBYTE_TO_FLOAT( src[0] );
1112 texel[ACOMP] = 1.0F;
1113 }
1114
1115 #if DIM == 3
1116 static void store_texel_l8(struct gl_texture_image *texImage,
1117 GLint i, GLint j, GLint k, const void *texel)
1118 {
1119 const GLubyte *rgba = (const GLubyte *) texel;
1120 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1121 *dst = rgba[RCOMP];
1122 }
1123 #endif
1124
1125
1126 /* MESA_FORMAT_I8 ************************************************************/
1127
1128 /* Fetch texel from 1D, 2D or 3D i8 texture, return 4 GLchans */
1129 static void FETCH(f_i8)( const struct gl_texture_image *texImage,
1130 GLint i, GLint j, GLint k, GLfloat *texel )
1131 {
1132 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1133 texel[RCOMP] =
1134 texel[GCOMP] =
1135 texel[BCOMP] =
1136 texel[ACOMP] = UBYTE_TO_FLOAT( src[0] );
1137 }
1138
1139 #if DIM == 3
1140 static void store_texel_i8(struct gl_texture_image *texImage,
1141 GLint i, GLint j, GLint k, const void *texel)
1142 {
1143 const GLubyte *rgba = (const GLubyte *) texel;
1144 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1145 *dst = rgba[RCOMP];
1146 }
1147 #endif
1148
1149
1150 /* MESA_FORMAT_CI8 ***********************************************************/
1151
1152 /* Fetch CI texel from 1D, 2D or 3D ci8 texture, lookup the index in a
1153 * color table, and return 4 GLchans.
1154 */
1155 static void FETCH(f_ci8)( const struct gl_texture_image *texImage,
1156 GLint i, GLint j, GLint k, GLfloat *texel )
1157 {
1158 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1159 const struct gl_color_table *palette;
1160 GLuint index;
1161 GET_CURRENT_CONTEXT(ctx);
1162
1163 if (ctx->Texture.SharedPalette) {
1164 palette = &ctx->Texture.Palette;
1165 }
1166 else {
1167 palette = &texImage->TexObject->Palette;
1168 }
1169 if (palette->Size == 0)
1170 return; /* undefined results */
1171
1172 /* Mask the index against size of palette to avoid going out of bounds */
1173 index = (*src) & (palette->Size - 1);
1174
1175 {
1176 const GLfloat *table = palette->TableF;
1177 switch (palette->_BaseFormat) {
1178 case GL_ALPHA:
1179 texel[RCOMP] =
1180 texel[GCOMP] =
1181 texel[BCOMP] = 0.0F;
1182 texel[ACOMP] = table[index];
1183 break;
1184 case GL_LUMINANCE:
1185 texel[RCOMP] =
1186 texel[GCOMP] =
1187 texel[BCOMP] = table[index];
1188 texel[ACOMP] = 1.0F;
1189 break;
1190 case GL_INTENSITY:
1191 texel[RCOMP] =
1192 texel[GCOMP] =
1193 texel[BCOMP] =
1194 texel[ACOMP] = table[index];
1195 break;
1196 case GL_LUMINANCE_ALPHA:
1197 texel[RCOMP] =
1198 texel[GCOMP] =
1199 texel[BCOMP] = table[index * 2 + 0];
1200 texel[ACOMP] = table[index * 2 + 1];
1201 break;
1202 case GL_RGB:
1203 texel[RCOMP] = table[index * 3 + 0];
1204 texel[GCOMP] = table[index * 3 + 1];
1205 texel[BCOMP] = table[index * 3 + 2];
1206 texel[ACOMP] = 1.0F;
1207 break;
1208 case GL_RGBA:
1209 texel[RCOMP] = table[index * 4 + 0];
1210 texel[GCOMP] = table[index * 4 + 1];
1211 texel[BCOMP] = table[index * 4 + 2];
1212 texel[ACOMP] = table[index * 4 + 3];
1213 break;
1214 default:
1215 _mesa_problem(ctx, "Bad palette format in fetch_texel_ci8");
1216 return;
1217 }
1218 }
1219 }
1220
1221 #if DIM == 3
1222 static void store_texel_ci8(struct gl_texture_image *texImage,
1223 GLint i, GLint j, GLint k, const void *texel)
1224 {
1225 const GLubyte *index = (const GLubyte *) texel;
1226 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1227 *dst = *index;
1228 }
1229 #endif
1230
1231
1232 /* Fetch texel from 1D, 2D or 3D srgb8 texture, return 4 GLfloats */
1233 /* Note: component order is same as for MESA_FORMAT_RGB888 */
1234 static void FETCH(srgb8)(const struct gl_texture_image *texImage,
1235 GLint i, GLint j, GLint k, GLfloat *texel )
1236 {
1237 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
1238 texel[RCOMP] = nonlinear_to_linear(src[2]);
1239 texel[GCOMP] = nonlinear_to_linear(src[1]);
1240 texel[BCOMP] = nonlinear_to_linear(src[0]);
1241 texel[ACOMP] = 1.0F;
1242 }
1243
1244 #if DIM == 3
1245 static void store_texel_srgb8(struct gl_texture_image *texImage,
1246 GLint i, GLint j, GLint k, const void *texel)
1247 {
1248 const GLubyte *rgba = (const GLubyte *) texel;
1249 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 3);
1250 dst[0] = rgba[BCOMP]; /* no conversion */
1251 dst[1] = rgba[GCOMP];
1252 dst[2] = rgba[RCOMP];
1253 }
1254 #endif
1255
1256 /* Fetch texel from 1D, 2D or 3D srgba8 texture, return 4 GLfloats */
1257 static void FETCH(srgba8)(const struct gl_texture_image *texImage,
1258 GLint i, GLint j, GLint k, GLfloat *texel )
1259 {
1260 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1261 texel[RCOMP] = nonlinear_to_linear( (s >> 24) );
1262 texel[GCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
1263 texel[BCOMP] = nonlinear_to_linear( (s >> 8) & 0xff );
1264 texel[ACOMP] = UBYTE_TO_FLOAT( (s ) & 0xff ); /* linear! */
1265 }
1266
1267 #if DIM == 3
1268 static void store_texel_srgba8(struct gl_texture_image *texImage,
1269 GLint i, GLint j, GLint k, const void *texel)
1270 {
1271 const GLubyte *rgba = (const GLubyte *) texel;
1272 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1273 *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1274 }
1275 #endif
1276
1277 /* Fetch texel from 1D, 2D or 3D sargb8 texture, return 4 GLfloats */
1278 static void FETCH(sargb8)(const struct gl_texture_image *texImage,
1279 GLint i, GLint j, GLint k, GLfloat *texel )
1280 {
1281 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1282 texel[RCOMP] = nonlinear_to_linear( (s >> 16) & 0xff );
1283 texel[GCOMP] = nonlinear_to_linear( (s >> 8) & 0xff );
1284 texel[BCOMP] = nonlinear_to_linear( (s ) & 0xff );
1285 texel[ACOMP] = UBYTE_TO_FLOAT( (s >> 24) ); /* linear! */
1286 }
1287
1288 #if DIM == 3
1289 static void store_texel_sargb8(struct gl_texture_image *texImage,
1290 GLint i, GLint j, GLint k, const void *texel)
1291 {
1292 const GLubyte *rgba = (const GLubyte *) texel;
1293 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1294 *dst = PACK_COLOR_8888(rgba[ACOMP], rgba[RCOMP], rgba[GCOMP], rgba[BCOMP]);
1295 }
1296 #endif
1297
1298 /* Fetch texel from 1D, 2D or 3D sl8 texture, return 4 GLfloats */
1299 static void FETCH(sl8)(const struct gl_texture_image *texImage,
1300 GLint i, GLint j, GLint k, GLfloat *texel )
1301 {
1302 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1303 texel[RCOMP] =
1304 texel[GCOMP] =
1305 texel[BCOMP] = nonlinear_to_linear(src[0]);
1306 texel[ACOMP] = 1.0F;
1307 }
1308
1309 #if DIM == 3
1310 static void store_texel_sl8(struct gl_texture_image *texImage,
1311 GLint i, GLint j, GLint k, const void *texel)
1312 {
1313 const GLubyte *rgba = (const GLubyte *) texel;
1314 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 1);
1315 dst[0] = rgba[RCOMP];
1316 }
1317 #endif
1318
1319 /* Fetch texel from 1D, 2D or 3D sla8 texture, return 4 GLfloats */
1320 static void FETCH(sla8)(const struct gl_texture_image *texImage,
1321 GLint i, GLint j, GLint k, GLfloat *texel )
1322 {
1323 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
1324 texel[RCOMP] =
1325 texel[GCOMP] =
1326 texel[BCOMP] = nonlinear_to_linear(src[0]);
1327 texel[ACOMP] = UBYTE_TO_FLOAT(src[1]); /* linear */
1328 }
1329
1330 #if DIM == 3
1331 static void store_texel_sla8(struct gl_texture_image *texImage,
1332 GLint i, GLint j, GLint k, const void *texel)
1333 {
1334 const GLubyte *rgba = (const GLubyte *) texel;
1335 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 2);
1336 dst[0] = rgba[RCOMP];
1337 dst[1] = rgba[ACOMP];
1338 }
1339 #endif
1340
1341
1342 /* MESA_FORMAT_RGBA_INT8 **************************************************/
1343
1344 static void
1345 FETCH(rgba_int8)(const struct gl_texture_image *texImage,
1346 GLint i, GLint j, GLint k, GLfloat *texel )
1347 {
1348 const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
1349 texel[RCOMP] = (GLfloat) src[0];
1350 texel[GCOMP] = (GLfloat) src[1];
1351 texel[BCOMP] = (GLfloat) src[2];
1352 texel[ACOMP] = (GLfloat) src[3];
1353 }
1354
1355 #if DIM == 3
1356 static void
1357 store_texel_rgba_int8(struct gl_texture_image *texImage,
1358 GLint i, GLint j, GLint k, const void *texel)
1359 {
1360 const GLbyte *rgba = (const GLbyte *) texel;
1361 GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 4);
1362 dst[0] = rgba[RCOMP];
1363 dst[1] = rgba[GCOMP];
1364 dst[2] = rgba[BCOMP];
1365 dst[3] = rgba[ACOMP];
1366 }
1367 #endif
1368
1369
1370 /* MESA_FORMAT_RGBA_INT16 **************************************************/
1371
1372 static void
1373 FETCH(rgba_int16)(const struct gl_texture_image *texImage,
1374 GLint i, GLint j, GLint k, GLfloat *texel )
1375 {
1376 const GLshort *src = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1377 texel[RCOMP] = (GLfloat) src[0];
1378 texel[GCOMP] = (GLfloat) src[1];
1379 texel[BCOMP] = (GLfloat) src[2];
1380 texel[ACOMP] = (GLfloat) src[3];
1381 }
1382
1383 #if DIM == 3
1384 static void
1385 store_texel_rgba_int16(struct gl_texture_image *texImage,
1386 GLint i, GLint j, GLint k, const void *texel)
1387 {
1388 const GLshort *rgba = (const GLshort *) texel;
1389 GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1390 dst[0] = rgba[RCOMP];
1391 dst[1] = rgba[GCOMP];
1392 dst[2] = rgba[BCOMP];
1393 dst[3] = rgba[ACOMP];
1394 }
1395 #endif
1396
1397
1398 /* MESA_FORMAT_RGBA_INT32 **************************************************/
1399
1400 static void
1401 FETCH(rgba_int32)(const struct gl_texture_image *texImage,
1402 GLint i, GLint j, GLint k, GLfloat *texel )
1403 {
1404 const GLint *src = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
1405 texel[RCOMP] = (GLfloat) src[0];
1406 texel[GCOMP] = (GLfloat) src[1];
1407 texel[BCOMP] = (GLfloat) src[2];
1408 texel[ACOMP] = (GLfloat) src[3];
1409 }
1410
1411 #if DIM == 3
1412 static void
1413 store_texel_rgba_int32(struct gl_texture_image *texImage,
1414 GLint i, GLint j, GLint k, const void *texel)
1415 {
1416 const GLint *rgba = (const GLint *) texel;
1417 GLint *dst = TEXEL_ADDR(GLint, texImage, i, j, k, 4);
1418 dst[0] = rgba[RCOMP];
1419 dst[1] = rgba[GCOMP];
1420 dst[2] = rgba[BCOMP];
1421 dst[3] = rgba[ACOMP];
1422 }
1423 #endif
1424
1425
1426 /* MESA_FORMAT_RGBA_UINT8 **************************************************/
1427
1428 static void
1429 FETCH(rgba_uint8)(const struct gl_texture_image *texImage,
1430 GLint i, GLint j, GLint k, GLfloat *texel )
1431 {
1432 const GLubyte *src = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
1433 texel[RCOMP] = (GLfloat) src[0];
1434 texel[GCOMP] = (GLfloat) src[1];
1435 texel[BCOMP] = (GLfloat) src[2];
1436 texel[ACOMP] = (GLfloat) src[3];
1437 }
1438
1439 #if DIM == 3
1440 static void
1441 store_texel_rgba_uint8(struct gl_texture_image *texImage,
1442 GLint i, GLint j, GLint k, const void *texel)
1443 {
1444 const GLubyte *rgba = (const GLubyte *) texel;
1445 GLubyte *dst = TEXEL_ADDR(GLubyte, texImage, i, j, k, 4);
1446 dst[0] = rgba[RCOMP];
1447 dst[1] = rgba[GCOMP];
1448 dst[2] = rgba[BCOMP];
1449 dst[3] = rgba[ACOMP];
1450 }
1451 #endif
1452
1453
1454 /* MESA_FORMAT_RGBA_UINT16 **************************************************/
1455
1456 static void
1457 FETCH(rgba_uint16)(const struct gl_texture_image *texImage,
1458 GLint i, GLint j, GLint k, GLfloat *texel )
1459 {
1460 const GLushort *src = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1461 texel[RCOMP] = (GLfloat) src[0];
1462 texel[GCOMP] = (GLfloat) src[1];
1463 texel[BCOMP] = (GLfloat) src[2];
1464 texel[ACOMP] = (GLfloat) src[3];
1465 }
1466
1467 #if DIM == 3
1468 static void
1469 store_texel_rgba_uint16(struct gl_texture_image *texImage,
1470 GLint i, GLint j, GLint k, const void *texel)
1471 {
1472 const GLushort *rgba = (const GLushort *) texel;
1473 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1474 dst[0] = rgba[RCOMP];
1475 dst[1] = rgba[GCOMP];
1476 dst[2] = rgba[BCOMP];
1477 dst[3] = rgba[ACOMP];
1478 }
1479 #endif
1480
1481
1482 /* MESA_FORMAT_RGBA_UINT32 **************************************************/
1483
1484 static void
1485 FETCH(rgba_uint32)(const struct gl_texture_image *texImage,
1486 GLint i, GLint j, GLint k, GLfloat *texel )
1487 {
1488 const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
1489 texel[RCOMP] = (GLfloat) src[0];
1490 texel[GCOMP] = (GLfloat) src[1];
1491 texel[BCOMP] = (GLfloat) src[2];
1492 texel[ACOMP] = (GLfloat) src[3];
1493 }
1494
1495 #if DIM == 3
1496 static void
1497 store_texel_rgba_uint32(struct gl_texture_image *texImage,
1498 GLint i, GLint j, GLint k, const void *texel)
1499 {
1500 const GLuint *rgba = (const GLuint *) texel;
1501 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 4);
1502 dst[0] = rgba[RCOMP];
1503 dst[1] = rgba[GCOMP];
1504 dst[2] = rgba[BCOMP];
1505 dst[3] = rgba[ACOMP];
1506 }
1507 #endif
1508
1509
1510 /* MESA_FORMAT_DUDV8 ********************************************************/
1511
1512 /* this format by definition produces 0,0,0,1 as rgba values,
1513 however we'll return the dudv values as rg and fix up elsewhere */
1514 static void FETCH(dudv8)(const struct gl_texture_image *texImage,
1515 GLint i, GLint j, GLint k, GLfloat *texel )
1516 {
1517 const GLbyte *src = TEXEL_ADDR(GLbyte, texImage, i, j, k, 2);
1518 texel[RCOMP] = BYTE_TO_FLOAT(src[0]);
1519 texel[GCOMP] = BYTE_TO_FLOAT(src[1]);
1520 texel[BCOMP] = 0;
1521 texel[ACOMP] = 0;
1522 }
1523
1524
1525 /* MESA_FORMAT_SIGNED_R8 ***********************************************/
1526
1527 static void FETCH(signed_r8)( const struct gl_texture_image *texImage,
1528 GLint i, GLint j, GLint k, GLfloat *texel )
1529 {
1530 const GLbyte s = *TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1531 texel[RCOMP] = BYTE_TO_FLOAT_TEX( s );
1532 texel[GCOMP] = 0.0F;
1533 texel[BCOMP] = 0.0F;
1534 texel[ACOMP] = 1.0F;
1535 }
1536
1537 #if DIM == 3
1538 static void store_texel_signed_r8(struct gl_texture_image *texImage,
1539 GLint i, GLint j, GLint k, const void *texel)
1540 {
1541 const GLbyte *rgba = (const GLbyte *) texel;
1542 GLbyte *dst = TEXEL_ADDR(GLbyte, texImage, i, j, k, 1);
1543 *dst = rgba[RCOMP];
1544 }
1545 #endif
1546
1547
1548 /* MESA_FORMAT_SIGNED_RG88 ***********************************************/
1549
1550 static void FETCH(signed_rg88)( const struct gl_texture_image *texImage,
1551 GLint i, GLint j, GLint k, GLfloat *texel )
1552 {
1553 const GLushort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1554 texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1555 texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s & 0xff) );
1556 texel[BCOMP] = 0.0F;
1557 texel[ACOMP] = 1.0F;
1558 }
1559
1560 #if DIM == 3
1561 static void store_texel_signed_rg88(struct gl_texture_image *texImage,
1562 GLint i, GLint j, GLint k, const void *texel)
1563 {
1564 const GLbyte *rg = (const GLbyte *) texel;
1565 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 2);
1566 *dst = PACK_COLOR_88(rg[RCOMP], rg[GCOMP]);
1567 }
1568 #endif
1569
1570
1571 /* MESA_FORMAT_SIGNED_RGBX8888 ***********************************************/
1572
1573 static void FETCH(signed_rgbx8888)( const struct gl_texture_image *texImage,
1574 GLint i, GLint j, GLint k, GLfloat *texel )
1575 {
1576 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1577 texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1578 texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1579 texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1580 texel[ACOMP] = 1.0f;
1581 }
1582
1583 #if DIM == 3
1584 static void store_texel_signed_rgbx8888(struct gl_texture_image *texImage,
1585 GLint i, GLint j, GLint k, const void *texel)
1586 {
1587 const GLbyte *rgba = (const GLbyte *) texel;
1588 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1589 *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], 255);
1590 }
1591 #endif
1592
1593
1594 /* MESA_FORMAT_SIGNED_RGBA8888 ***********************************************/
1595
1596 static void FETCH(signed_rgba8888)( const struct gl_texture_image *texImage,
1597 GLint i, GLint j, GLint k, GLfloat *texel )
1598 {
1599 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1600 texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1601 texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1602 texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1603 texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s ) );
1604 }
1605
1606 #if DIM == 3
1607 static void store_texel_signed_rgba8888(struct gl_texture_image *texImage,
1608 GLint i, GLint j, GLint k, const void *texel)
1609 {
1610 const GLbyte *rgba = (const GLbyte *) texel;
1611 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1612 *dst = PACK_COLOR_8888(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1613 }
1614 #endif
1615
1616 static void FETCH(signed_rgba8888_rev)( const struct gl_texture_image *texImage,
1617 GLint i, GLint j, GLint k, GLfloat *texel )
1618 {
1619 const GLuint s = *TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1620 texel[RCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s ) );
1621 texel[GCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 8) );
1622 texel[BCOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 16) );
1623 texel[ACOMP] = BYTE_TO_FLOAT_TEX( (GLbyte) (s >> 24) );
1624 }
1625
1626 #if DIM == 3
1627 static void store_texel_signed_rgba8888_rev(struct gl_texture_image *texImage,
1628 GLint i, GLint j, GLint k, const void *texel)
1629 {
1630 const GLubyte *rgba = (const GLubyte *) texel;
1631 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1632 *dst = PACK_COLOR_8888_REV(rgba[RCOMP], rgba[GCOMP], rgba[BCOMP], rgba[ACOMP]);
1633 }
1634 #endif
1635
1636
1637
1638 /* MESA_FORMAT_SIGNED_R_16 ***********************************************/
1639
1640 static void
1641 FETCH(signed_r_16)(const struct gl_texture_image *texImage,
1642 GLint i, GLint j, GLint k, GLfloat *texel)
1643 {
1644 const GLshort s = *TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1645 texel[RCOMP] = SHORT_TO_FLOAT_TEX( s );
1646 texel[GCOMP] = 0.0F;
1647 texel[BCOMP] = 0.0F;
1648 texel[ACOMP] = 1.0F;
1649 }
1650
1651 #if DIM == 3
1652 static void
1653 store_texel_signed_r_16(struct gl_texture_image *texImage,
1654 GLint i, GLint j, GLint k, const void *texel)
1655 {
1656 const GLshort *rgba = (const GLshort *) texel;
1657 GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 1);
1658 *dst = rgba[0];
1659 }
1660 #endif
1661
1662
1663 /* MESA_FORMAT_SIGNED_RG_16 ***********************************************/
1664
1665 static void
1666 FETCH(signed_rg_16)(const struct gl_texture_image *texImage,
1667 GLint i, GLint j, GLint k, GLfloat *texel)
1668 {
1669 const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
1670 texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
1671 texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
1672 texel[BCOMP] = 0.0F;
1673 texel[ACOMP] = 1.0F;
1674 }
1675
1676 #if DIM == 3
1677 static void
1678 store_texel_signed_rg_16(struct gl_texture_image *texImage,
1679 GLint i, GLint j, GLint k, const void *texel)
1680 {
1681 const GLshort *rgba = (const GLshort *) texel;
1682 GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 2);
1683 dst[0] = rgba[RCOMP];
1684 dst[1] = rgba[GCOMP];
1685 }
1686 #endif
1687
1688
1689 /* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/
1690
1691 static void
1692 FETCH(signed_rgb_16)(const struct gl_texture_image *texImage,
1693 GLint i, GLint j, GLint k, GLfloat *texel)
1694 {
1695 const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
1696 texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
1697 texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
1698 texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
1699 texel[ACOMP] = 1.0F;
1700 }
1701
1702 #if DIM == 3
1703 static void
1704 store_texel_signed_rgb_16(struct gl_texture_image *texImage,
1705 GLint i, GLint j, GLint k, const void *texel)
1706 {
1707 const GLshort *rgba = (const GLshort *) texel;
1708 GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 3);
1709 dst[0] = rgba[RCOMP];
1710 dst[1] = rgba[GCOMP];
1711 dst[2] = rgba[BCOMP];
1712 }
1713 #endif
1714
1715
1716 /* MESA_FORMAT_SIGNED_RGBA_16 ***********************************************/
1717
1718 static void
1719 FETCH(signed_rgba_16)(const struct gl_texture_image *texImage,
1720 GLint i, GLint j, GLint k, GLfloat *texel)
1721 {
1722 const GLshort *s = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1723 texel[RCOMP] = SHORT_TO_FLOAT_TEX( s[0] );
1724 texel[GCOMP] = SHORT_TO_FLOAT_TEX( s[1] );
1725 texel[BCOMP] = SHORT_TO_FLOAT_TEX( s[2] );
1726 texel[ACOMP] = SHORT_TO_FLOAT_TEX( s[3] );
1727 }
1728
1729 #if DIM == 3
1730 static void
1731 store_texel_signed_rgba_16(struct gl_texture_image *texImage,
1732 GLint i, GLint j, GLint k, const void *texel)
1733 {
1734 const GLshort *rgba = (const GLshort *) texel;
1735 GLshort *dst = TEXEL_ADDR(GLshort, texImage, i, j, k, 4);
1736 dst[0] = rgba[RCOMP];
1737 dst[1] = rgba[GCOMP];
1738 dst[2] = rgba[BCOMP];
1739 dst[3] = rgba[ACOMP];
1740 }
1741 #endif
1742
1743
1744
1745 /* MESA_FORMAT_RGBA_16 ***********************************************/
1746
1747 static void
1748 FETCH(rgba_16)(const struct gl_texture_image *texImage,
1749 GLint i, GLint j, GLint k, GLfloat *texel)
1750 {
1751 const GLushort *s = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1752 texel[RCOMP] = USHORT_TO_FLOAT( s[0] );
1753 texel[GCOMP] = USHORT_TO_FLOAT( s[1] );
1754 texel[BCOMP] = USHORT_TO_FLOAT( s[2] );
1755 texel[ACOMP] = USHORT_TO_FLOAT( s[3] );
1756 }
1757
1758 #if DIM == 3
1759 static void
1760 store_texel_rgba_16(struct gl_texture_image *texImage,
1761 GLint i, GLint j, GLint k, const void *texel)
1762 {
1763 const GLushort *rgba = (const GLushort *) texel;
1764 GLushort *dst = TEXEL_ADDR(GLushort, texImage, i, j, k, 4);
1765 dst[0] = rgba[RCOMP];
1766 dst[1] = rgba[GCOMP];
1767 dst[2] = rgba[BCOMP];
1768 dst[3] = rgba[ACOMP];
1769 }
1770 #endif
1771
1772
1773
1774 /* MESA_FORMAT_YCBCR *********************************************************/
1775
1776 /* Fetch texel from 1D, 2D or 3D ycbcr texture, return 4 GLfloats.
1777 * We convert YCbCr to RGB here.
1778 */
1779 static void FETCH(f_ycbcr)( const struct gl_texture_image *texImage,
1780 GLint i, GLint j, GLint k, GLfloat *texel )
1781 {
1782 const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
1783 const GLushort *src1 = src0 + 1; /* odd */
1784 const GLubyte y0 = (*src0 >> 8) & 0xff; /* luminance */
1785 const GLubyte cb = *src0 & 0xff; /* chroma U */
1786 const GLubyte y1 = (*src1 >> 8) & 0xff; /* luminance */
1787 const GLubyte cr = *src1 & 0xff; /* chroma V */
1788 const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */
1789 GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
1790 GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
1791 GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
1792 r *= (1.0F / 255.0F);
1793 g *= (1.0F / 255.0F);
1794 b *= (1.0F / 255.0F);
1795 texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
1796 texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
1797 texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
1798 texel[ACOMP] = 1.0F;
1799 }
1800
1801 #if DIM == 3
1802 static void store_texel_ycbcr(struct gl_texture_image *texImage,
1803 GLint i, GLint j, GLint k, const void *texel)
1804 {
1805 (void) texImage;
1806 (void) i;
1807 (void) j;
1808 (void) k;
1809 (void) texel;
1810 /* XXX to do */
1811 }
1812 #endif
1813
1814
1815 /* MESA_FORMAT_YCBCR_REV *****************************************************/
1816
1817 /* Fetch texel from 1D, 2D or 3D ycbcr_rev texture, return 4 GLfloats.
1818 * We convert YCbCr to RGB here.
1819 */
1820 static void FETCH(f_ycbcr_rev)( const struct gl_texture_image *texImage,
1821 GLint i, GLint j, GLint k, GLfloat *texel )
1822 {
1823 const GLushort *src0 = TEXEL_ADDR(GLushort, texImage, (i & ~1), j, k, 1); /* even */
1824 const GLushort *src1 = src0 + 1; /* odd */
1825 const GLubyte y0 = *src0 & 0xff; /* luminance */
1826 const GLubyte cr = (*src0 >> 8) & 0xff; /* chroma V */
1827 const GLubyte y1 = *src1 & 0xff; /* luminance */
1828 const GLubyte cb = (*src1 >> 8) & 0xff; /* chroma U */
1829 const GLubyte y = (i & 1) ? y1 : y0; /* choose even/odd luminance */
1830 GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
1831 GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
1832 GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
1833 r *= (1.0F / 255.0F);
1834 g *= (1.0F / 255.0F);
1835 b *= (1.0F / 255.0F);
1836 texel[RCOMP] = CLAMP(r, 0.0F, 1.0F);
1837 texel[GCOMP] = CLAMP(g, 0.0F, 1.0F);
1838 texel[BCOMP] = CLAMP(b, 0.0F, 1.0F);
1839 texel[ACOMP] = 1.0F;
1840 }
1841
1842 #if DIM == 3
1843 static void store_texel_ycbcr_rev(struct gl_texture_image *texImage,
1844 GLint i, GLint j, GLint k, const void *texel)
1845 {
1846 (void) texImage;
1847 (void) i;
1848 (void) j;
1849 (void) k;
1850 (void) texel;
1851 /* XXX to do */
1852 }
1853 #endif
1854
1855
1856 /* MESA_TEXFORMAT_Z24_S8 ***************************************************/
1857
1858 static void FETCH(f_z24_s8)( const struct gl_texture_image *texImage,
1859 GLint i, GLint j, GLint k, GLfloat *texel )
1860 {
1861 /* only return Z, not stencil data */
1862 const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1863 const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
1864 texel[0] = ((*src) >> 8) * scale;
1865 ASSERT(texImage->TexFormat == MESA_FORMAT_Z24_S8);
1866 ASSERT(texel[0] >= 0.0F);
1867 ASSERT(texel[0] <= 1.0F);
1868 }
1869
1870 #if DIM == 3
1871 static void store_texel_z24_s8(struct gl_texture_image *texImage,
1872 GLint i, GLint j, GLint k, const void *texel)
1873 {
1874 /* only store Z, not stencil */
1875 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1876 GLfloat depth = *((GLfloat *) texel);
1877 GLuint zi = ((GLuint) (depth * 0xffffff)) << 8;
1878 *dst = zi | (*dst & 0xff);
1879 }
1880 #endif
1881
1882
1883 /* MESA_TEXFORMAT_S8_Z24 ***************************************************/
1884
1885 static void FETCH(f_s8_z24)( const struct gl_texture_image *texImage,
1886 GLint i, GLint j, GLint k, GLfloat *texel )
1887 {
1888 /* only return Z, not stencil data */
1889 const GLuint *src = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1890 const GLfloat scale = 1.0F / (GLfloat) 0xffffff;
1891 texel[0] = ((*src) & 0x00ffffff) * scale;
1892 ASSERT(texImage->TexFormat == MESA_FORMAT_S8_Z24);
1893 ASSERT(texel[0] >= 0.0F);
1894 ASSERT(texel[0] <= 1.0F);
1895 }
1896
1897 #if DIM == 3
1898 static void store_texel_s8_z24(struct gl_texture_image *texImage,
1899 GLint i, GLint j, GLint k, const void *texel)
1900 {
1901 /* only store Z, not stencil */
1902 GLuint *dst = TEXEL_ADDR(GLuint, texImage, i, j, k, 1);
1903 GLfloat depth = *((GLfloat *) texel);
1904 GLuint zi = (GLuint) (depth * 0xffffff);
1905 *dst = zi | (*dst & 0xff000000);
1906 }
1907 #endif
1908
1909
1910 #undef TEXEL_ADDR
1911 #undef DIM
1912 #undef FETCH