projects / mesa.git / blob
? search:


b870001d909bec2b600d43b0cc64d0a6707e6162
[mesa.git] / src / mesa / main / format_pack.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 OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * Color, depth, stencil packing functions.
28 * Used to pack basic color, depth and stencil formats to specific
29 * hardware formats.
30 *
31 * There are both per-pixel and per-row packing functions:
32 * - The former will be used by swrast to write values to the color, depth,
33 * stencil buffers when drawing points, lines and masked spans.
34 * - The later will be used for image-oriented functions like glDrawPixels,
35 * glAccum, and glTexImage.
36 */
37
38
39 #include "colormac.h"
40 #include "format_pack.h"
41 #include "macros.h"
42 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
43 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
44
45
46 /** Helper struct for MESA_FORMAT_Z32_FLOAT_S8X24_UINT */
47 struct z32f_x24s8
48 {
49 float z;
50 uint32_t x24s8;
51 };
52
53
54 typedef void (*pack_ubyte_rgba_row_func)(GLuint n,
55 const GLubyte src[][4], void *dst);
56
57 typedef void (*pack_float_rgba_row_func)(GLuint n,
58 const GLfloat src[][4], void *dst);
59
60
61
62 static inline GLfloat
63 linear_to_srgb(GLfloat cl)
64 {
65 if (cl < 0.0f)
66 return 0.0f;
67 else if (cl < 0.0031308f)
68 return 12.92f * cl;
69 else if (cl < 1.0f)
70 return 1.055f * powf(cl, 0.41666f) - 0.055f;
71 else
72 return 1.0f;
73 }
74
75
76 static inline GLubyte
77 linear_float_to_srgb_ubyte(GLfloat cl)
78 {
79 GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl));
80 return res;
81 }
82
83
84 static inline GLubyte
85 linear_ubyte_to_srgb_ubyte(GLubyte cl)
86 {
87 GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl / 255.0f));
88 return res;
89 }
90
91
92
93
94 /*
95 * MESA_FORMAT_A8B8G8R8_UNORM
96 */
97
98 static void
99 pack_ubyte_RGBA8888(const GLubyte src[4], void *dst)
100 {
101 GLuint *d = ((GLuint *) dst);
102 *d = PACK_COLOR_8888(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
103 }
104
105 static void
106 pack_float_RGBA8888(const GLfloat src[4], void *dst)
107 {
108 GLubyte v[4];
109 _mesa_unclamped_float_rgba_to_ubyte(v, src);
110 pack_ubyte_RGBA8888(v, dst);
111 }
112
113 static void
114 pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
115 {
116 GLuint *d = ((GLuint *) dst);
117 GLuint i;
118 for (i = 0; i < n; i++) {
119 d[i] = PACK_COLOR_8888(src[i][RCOMP], src[i][GCOMP],
120 src[i][BCOMP], src[i][ACOMP]);
121 }
122 }
123
124 static void
125 pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
126 {
127 GLuint *d = ((GLuint *) dst);
128 GLuint i;
129 for (i = 0; i < n; i++) {
130 GLubyte v[4];
131 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
132 pack_ubyte_RGBA8888(v, d + i);
133 }
134 }
135
136
137
138 /*
139 * MESA_FORMAT_R8G8B8A8_UNORM
140 */
141
142 static void
143 pack_ubyte_RGBA8888_REV(const GLubyte src[4], void *dst)
144 {
145 GLuint *d = ((GLuint *) dst);
146 *d = PACK_COLOR_8888(src[ACOMP], src[BCOMP], src[GCOMP], src[RCOMP]);
147 }
148
149 static void
150 pack_float_RGBA8888_REV(const GLfloat src[4], void *dst)
151 {
152 GLubyte v[4];
153 _mesa_unclamped_float_rgba_to_ubyte(v, src);
154 pack_ubyte_RGBA8888_REV(v, dst);
155 }
156
157 static void
158 pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
159 {
160 GLuint *d = ((GLuint *) dst);
161 GLuint i;
162 for (i = 0; i < n; i++) {
163 d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][BCOMP],
164 src[i][GCOMP], src[i][RCOMP]);
165 }
166 }
167
168 static void
169 pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
170 {
171 GLuint *d = ((GLuint *) dst);
172 GLuint i;
173 for (i = 0; i < n; i++) {
174 GLubyte v[4];
175 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
176 pack_ubyte_RGBA8888_REV(v, d + i);
177 }
178 }
179
180
181 /*
182 * MESA_FORMAT_B8G8R8A8_UNORM
183 */
184
185 static void
186 pack_ubyte_ARGB8888(const GLubyte src[4], void *dst)
187 {
188 GLuint *d = ((GLuint *) dst);
189 *d = PACK_COLOR_8888(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
190 }
191
192 static void
193 pack_float_ARGB8888(const GLfloat src[4], void *dst)
194 {
195 GLubyte v[4];
196 _mesa_unclamped_float_rgba_to_ubyte(v, src);
197 pack_ubyte_ARGB8888(v, dst);
198 }
199
200 static void
201 pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
202 {
203 GLuint *d = ((GLuint *) dst);
204 GLuint i;
205 for (i = 0; i < n; i++) {
206 d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][RCOMP],
207 src[i][GCOMP], src[i][BCOMP]);
208 }
209 }
210
211 static void
212 pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
213 {
214 GLuint *d = ((GLuint *) dst);
215 GLuint i;
216 for (i = 0; i < n; i++) {
217 GLubyte v[4];
218 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
219 pack_ubyte_ARGB8888(v, d + i);
220 }
221 }
222
223
224 /*
225 * MESA_FORMAT_A8R8G8B8_UNORM
226 */
227
228 static void
229 pack_ubyte_ARGB8888_REV(const GLubyte src[4], void *dst)
230 {
231 GLuint *d = ((GLuint *) dst);
232 *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
233 }
234
235 static void
236 pack_float_ARGB8888_REV(const GLfloat src[4], void *dst)
237 {
238 GLubyte v[4];
239 _mesa_unclamped_float_rgba_to_ubyte(v, src);
240 pack_ubyte_ARGB8888_REV(v, dst);
241 }
242
243 static void
244 pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
245 {
246 GLuint *d = ((GLuint *) dst);
247 GLuint i;
248 for (i = 0; i < n; i++) {
249 d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP],
250 src[i][RCOMP], src[i][ACOMP]);
251 }
252 }
253
254 static void
255 pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
256 {
257 GLuint *d = ((GLuint *) dst);
258 GLuint i;
259 for (i = 0; i < n; i++) {
260 GLubyte v[4];
261 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
262 pack_ubyte_ARGB8888_REV(v, d + i);
263 }
264 }
265
266
267 /*
268 * MESA_FORMAT_B8G8R8X8_UNORM
269 */
270
271 static void
272 pack_ubyte_XRGB8888(const GLubyte src[4], void *dst)
273 {
274 GLuint *d = ((GLuint *) dst);
275 *d = PACK_COLOR_8888(0x0, src[RCOMP], src[GCOMP], src[BCOMP]);
276 }
277
278 static void
279 pack_float_XRGB8888(const GLfloat src[4], void *dst)
280 {
281 GLubyte v[4];
282 _mesa_unclamped_float_rgba_to_ubyte(v, src);
283 pack_ubyte_XRGB8888(v, dst);
284 }
285
286 static void
287 pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
288 {
289 GLuint *d = ((GLuint *) dst);
290 GLuint i;
291 for (i = 0; i < n; i++) {
292 d[i] = PACK_COLOR_8888(0, src[i][RCOMP], src[i][GCOMP], src[i][BCOMP]);
293 }
294 }
295
296 static void
297 pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
298 {
299 GLuint *d = ((GLuint *) dst);
300 GLuint i;
301 for (i = 0; i < n; i++) {
302 GLubyte v[4];
303 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
304 pack_ubyte_XRGB8888(v, d + i);
305 }
306 }
307
308
309 /*
310 * MESA_FORMAT_X8R8G8B8_UNORM
311 */
312
313 static void
314 pack_ubyte_XRGB8888_REV(const GLubyte src[4], void *dst)
315 {
316 GLuint *d = ((GLuint *) dst);
317 *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], 0);
318 }
319
320 static void
321 pack_float_XRGB8888_REV(const GLfloat src[4], void *dst)
322 {
323 GLubyte v[4];
324 _mesa_unclamped_float_rgba_to_ubyte(v, src);
325 pack_ubyte_XRGB8888_REV(v, dst);
326 }
327
328 static void
329 pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
330 {
331 GLuint *d = ((GLuint *) dst);
332 GLuint i;
333 for (i = 0; i < n; i++) {
334 d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP], src[i][RCOMP], 0);
335 }
336 }
337
338 static void
339 pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
340 {
341 GLuint *d = ((GLuint *) dst);
342 GLuint i;
343 for (i = 0; i < n; i++) {
344 GLubyte v[4];
345 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
346 pack_ubyte_XRGB8888_REV(v, d + i);
347 }
348 }
349
350
351 /*
352 * MESA_FORMAT_BGR_UNORM8
353 */
354
355 static void
356 pack_ubyte_RGB888(const GLubyte src[4], void *dst)
357 {
358 GLubyte *d = ((GLubyte *) dst);
359 d[2] = src[RCOMP];
360 d[1] = src[GCOMP];
361 d[0] = src[BCOMP];
362 }
363
364 static void
365 pack_float_RGB888(const GLfloat src[4], void *dst)
366 {
367 GLubyte *d = ((GLubyte *) dst);
368 UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[RCOMP]);
369 UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
370 UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[BCOMP]);
371 }
372
373 static void
374 pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
375 {
376 GLubyte *d = ((GLubyte *) dst);
377 GLuint i;
378 for (i = 0; i < n; i++) {
379 d[i*3+2] = src[i][RCOMP];
380 d[i*3+1] = src[i][GCOMP];
381 d[i*3+0] = src[i][BCOMP];
382 }
383 }
384
385 static void
386 pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
387 {
388 GLubyte *d = ((GLubyte *) dst);
389 GLuint i;
390 for (i = 0; i < n; i++) {
391 GLubyte v[4];
392 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
393 d[i*3+2] = v[RCOMP];
394 d[i*3+1] = v[GCOMP];
395 d[i*3+0] = v[BCOMP];
396 }
397 }
398
399
400 /*
401 * MESA_FORMAT_RGB_UNORM8
402 */
403
404 static void
405 pack_ubyte_BGR888(const GLubyte src[4], void *dst)
406 {
407 GLubyte *d = ((GLubyte *) dst);
408 d[2] = src[BCOMP];
409 d[1] = src[GCOMP];
410 d[0] = src[RCOMP];
411 }
412
413 static void
414 pack_float_BGR888(const GLfloat src[4], void *dst)
415 {
416 GLubyte *d = ((GLubyte *) dst);
417 UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[BCOMP]);
418 UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
419 UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
420 }
421
422 static void
423 pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
424 {
425 GLubyte *d = ((GLubyte *) dst);
426 GLuint i;
427 for (i = 0; i < n; i++) {
428 d[i*3+2] = src[i][BCOMP];
429 d[i*3+1] = src[i][GCOMP];
430 d[i*3+0] = src[i][RCOMP];
431 }
432 }
433
434 static void
435 pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
436 {
437 GLubyte *d = ((GLubyte *) dst);
438 GLuint i;
439 for (i = 0; i < n; i++) {
440 GLubyte v[4];
441 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
442 d[i*3+2] = v[BCOMP];
443 d[i*3+1] = v[GCOMP];
444 d[i*3+0] = v[RCOMP];
445 }
446 }
447
448
449 /*
450 * MESA_FORMAT_B5G6R5_UNORM
451 */
452
453 static void
454 pack_ubyte_RGB565(const GLubyte src[4], void *dst)
455 {
456 GLushort *d = ((GLushort *) dst);
457 *d = PACK_COLOR_565(src[RCOMP], src[GCOMP], src[BCOMP]);
458 }
459
460 static void
461 pack_float_RGB565(const GLfloat src[4], void *dst)
462 {
463 GLubyte v[3];
464 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
465 UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
466 UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
467 pack_ubyte_RGB565(v, dst);
468 }
469
470 static void
471 pack_row_ubyte_RGB565(GLuint n, const GLubyte src[][4], void *dst)
472 {
473 GLushort *d = ((GLushort *) dst);
474 GLuint i;
475 for (i = 0; i < n; i++) {
476 pack_ubyte_RGB565(src[i], d + i);
477 }
478 }
479
480 static void
481 pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
482 {
483 GLushort *d = ((GLushort *) dst);
484 GLuint i;
485 for (i = 0; i < n; i++) {
486 GLubyte v[4];
487 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
488 pack_ubyte_RGB565(v, d + i);
489 }
490 }
491
492
493 /*
494 * MESA_FORMAT_R5G6B5_UNORM
495 * Warning: these functions do not match the current Mesa definition
496 * of MESA_FORMAT_R5G6B5_UNORM.
497 */
498
499 static void
500 pack_ubyte_RGB565_REV(const GLubyte src[4], void *dst)
501 {
502 GLushort *d = ((GLushort *) dst);
503 *d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
504 }
505
506 static void
507 pack_float_RGB565_REV(const GLfloat src[4], void *dst)
508 {
509 GLushort *d = ((GLushort *) dst);
510 GLubyte r, g, b;
511 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
512 UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
513 UNCLAMPED_FLOAT_TO_UBYTE(b, src[BCOMP]);
514 *d = PACK_COLOR_565_REV(r, g, b);
515 }
516
517 static void
518 pack_row_ubyte_RGB565_REV(GLuint n, const GLubyte src[][4], void *dst)
519 {
520 GLushort *d = ((GLushort *) dst);
521 GLuint i;
522 for (i = 0; i < n; i++) {
523 pack_ubyte_RGB565_REV(src[i], d + i);
524 }
525 }
526
527 static void
528 pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
529 {
530 GLushort *d = ((GLushort *) dst);
531 GLuint i;
532 for (i = 0; i < n; i++) {
533 GLubyte v[4];
534 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
535 pack_ubyte_RGB565_REV(v, d + i);
536 }
537 }
538
539
540 /*
541 * MESA_FORMAT_B4G4R4A4_UNORM
542 */
543
544 static void
545 pack_ubyte_ARGB4444(const GLubyte src[4], void *dst)
546 {
547 GLushort *d = ((GLushort *) dst);
548 *d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
549 }
550
551 static void
552 pack_float_ARGB4444(const GLfloat src[4], void *dst)
553 {
554 GLubyte v[4];
555 _mesa_unclamped_float_rgba_to_ubyte(v, src);
556 pack_ubyte_ARGB4444(v, dst);
557 }
558
559 /* use fallback row packing functions */
560
561
562 /*
563 * MESA_FORMAT_A4R4G4B4_UNORM
564 */
565
566 static void
567 pack_ubyte_ARGB4444_REV(const GLubyte src[4], void *dst)
568 {
569 GLushort *d = ((GLushort *) dst);
570 *d = PACK_COLOR_4444(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
571 }
572
573 static void
574 pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
575 {
576 GLubyte v[4];
577 _mesa_unclamped_float_rgba_to_ubyte(v, src);
578 pack_ubyte_ARGB4444_REV(v, dst);
579 }
580
581 /* use fallback row packing functions */
582
583
584 /*
585 * MESA_FORMAT_A1B5G5R5_UNORM
586 */
587
588 static void
589 pack_ubyte_RGBA5551(const GLubyte src[4], void *dst)
590 {
591 GLushort *d = ((GLushort *) dst);
592 *d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
593 }
594
595 static void
596 pack_float_RGBA5551(const GLfloat src[4], void *dst)
597 {
598 GLubyte v[4];
599 _mesa_unclamped_float_rgba_to_ubyte(v, src);
600 pack_ubyte_RGBA5551(v, dst);
601 }
602
603 /* use fallback row packing functions */
604
605
606 /*
607 * MESA_FORMAT_B5G5R5A1_UNORM
608 */
609
610 static void
611 pack_ubyte_ARGB1555(const GLubyte src[4], void *dst)
612 {
613 GLushort *d = ((GLushort *) dst);
614 *d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
615 }
616
617 static void
618 pack_float_ARGB1555(const GLfloat src[4], void *dst)
619 {
620 GLubyte v[4];
621 _mesa_unclamped_float_rgba_to_ubyte(v, src);
622 pack_ubyte_ARGB1555(v, dst);
623 }
624
625
626 /* MESA_FORMAT_A1R5G5B5_UNORM
627 * Warning: these functions do not match the current Mesa definition
628 * of MESA_FORMAT_A1R5G5B5_UNORM.
629 */
630
631 static void
632 pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
633 {
634 GLushort *d = ((GLushort *) dst), tmp;
635 tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
636 *d = (tmp >> 8) | (tmp << 8);
637 }
638
639 static void
640 pack_float_ARGB1555_REV(const GLfloat src[4], void *dst)
641 {
642 GLubyte v[4];
643 _mesa_unclamped_float_rgba_to_ubyte(v, src);
644 pack_ubyte_ARGB1555_REV(v, dst);
645 }
646
647
648 /* MESA_FORMAT_L4A4_UNORM */
649
650 static void
651 pack_ubyte_AL44(const GLubyte src[4], void *dst)
652 {
653 GLubyte *d = ((GLubyte *) dst);
654 *d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
655 }
656
657 static void
658 pack_float_AL44(const GLfloat src[4], void *dst)
659 {
660 GLubyte v[4];
661 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
662 UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
663 pack_ubyte_AL44(v, dst);
664 }
665
666
667 /* MESA_FORMAT_L8A8_UNORM */
668
669 static void
670 pack_ubyte_AL88(const GLubyte src[4], void *dst)
671 {
672 GLushort *d = ((GLushort *) dst);
673 *d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
674 }
675
676 static void
677 pack_float_AL88(const GLfloat src[4], void *dst)
678 {
679 GLubyte v[4];
680 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
681 UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
682 pack_ubyte_AL88(v, dst);
683 }
684
685
686 /* MESA_FORMAT_A8L8_UNORM */
687
688 static void
689 pack_ubyte_AL88_REV(const GLubyte src[4], void *dst)
690 {
691 GLushort *d = ((GLushort *) dst);
692 *d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
693 }
694
695 static void
696 pack_float_AL88_REV(const GLfloat src[4], void *dst)
697 {
698 GLubyte v[4];
699 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
700 UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
701 pack_ubyte_AL88_REV(v, dst);
702 }
703
704
705 /* MESA_FORMAT_L16A16_UNORM */
706
707 static void
708 pack_ubyte_AL1616(const GLubyte src[4], void *dst)
709 {
710 GLuint *d = ((GLuint *) dst);
711 GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
712 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
713 *d = PACK_COLOR_1616(a, l);
714 }
715
716 static void
717 pack_float_AL1616(const GLfloat src[4], void *dst)
718 {
719 GLuint *d = ((GLuint *) dst);
720 GLushort l, a;
721 UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
722 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
723 *d = PACK_COLOR_1616(a, l);
724 }
725
726
727 /* MESA_FORMAT_A16L16_UNORM */
728
729 static void
730 pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
731 {
732 GLuint *d = ((GLuint *) dst);
733 GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
734 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
735 *d = PACK_COLOR_1616(l, a);
736 }
737
738 static void
739 pack_float_AL1616_REV(const GLfloat src[4], void *dst)
740 {
741 GLuint *d = ((GLuint *) dst);
742 GLushort l, a;
743 UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
744 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
745 *d = PACK_COLOR_1616(l, a);
746 }
747
748
749 /* MESA_FORMAT_B2G3R3_UNORM */
750
751 static void
752 pack_ubyte_RGB332(const GLubyte src[4], void *dst)
753 {
754 GLubyte *d = ((GLubyte *) dst);
755 *d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
756 }
757
758 static void
759 pack_float_RGB332(const GLfloat src[4], void *dst)
760 {
761 GLubyte v[4];
762 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
763 UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
764 UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
765 pack_ubyte_RGB332(v, dst);
766 }
767
768
769 /* MESA_FORMAT_A_UNORM8 */
770
771 static void
772 pack_ubyte_A8(const GLubyte src[4], void *dst)
773 {
774 GLubyte *d = ((GLubyte *) dst);
775 *d = src[ACOMP];
776 }
777
778 static void
779 pack_float_A8(const GLfloat src[4], void *dst)
780 {
781 GLubyte *d = ((GLubyte *) dst);
782 UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
783 }
784
785
786 /* MESA_FORMAT_A_UNORM16 */
787
788 static void
789 pack_ubyte_A16(const GLubyte src[4], void *dst)
790 {
791 GLushort *d = ((GLushort *) dst);
792 *d = UBYTE_TO_USHORT(src[ACOMP]);
793 }
794
795 static void
796 pack_float_A16(const GLfloat src[4], void *dst)
797 {
798 GLushort *d = ((GLushort *) dst);
799 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
800 }
801
802
803 /* MESA_FORMAT_L_UNORM8 */
804
805 static void
806 pack_ubyte_L8(const GLubyte src[4], void *dst)
807 {
808 GLubyte *d = ((GLubyte *) dst);
809 *d = src[RCOMP];
810 }
811
812 static void
813 pack_float_L8(const GLfloat src[4], void *dst)
814 {
815 GLubyte *d = ((GLubyte *) dst);
816 UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
817 }
818
819
820 /* MESA_FORMAT_L_UNORM16 */
821
822 static void
823 pack_ubyte_L16(const GLubyte src[4], void *dst)
824 {
825 GLushort *d = ((GLushort *) dst);
826 *d = UBYTE_TO_USHORT(src[RCOMP]);
827 }
828
829 static void
830 pack_float_L16(const GLfloat src[4], void *dst)
831 {
832 GLushort *d = ((GLushort *) dst);
833 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
834 }
835
836
837 /* MESA_FORMAT_YCBCR */
838
839 static void
840 pack_ubyte_YCBCR(const GLubyte src[4], void *dst)
841 {
842 /* todo */
843 }
844
845 static void
846 pack_float_YCBCR(const GLfloat src[4], void *dst)
847 {
848 /* todo */
849 }
850
851
852 /* MESA_FORMAT_YCBCR_REV */
853
854 static void
855 pack_ubyte_YCBCR_REV(const GLubyte src[4], void *dst)
856 {
857 /* todo */
858 }
859
860 static void
861 pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
862 {
863 /* todo */
864 }
865
866
867 /* MESA_FORMAT_R_UNORM8 */
868
869 static void
870 pack_ubyte_R8(const GLubyte src[4], void *dst)
871 {
872 GLubyte *d = ((GLubyte *) dst);
873 *d = src[RCOMP];
874 }
875
876 static void
877 pack_float_R8(const GLfloat src[4], void *dst)
878 {
879 GLubyte *d = ((GLubyte *) dst);
880 GLubyte r;
881 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
882 d[0] = r;
883 }
884
885
886 /* MESA_FORMAT_R8G8_UNORM */
887
888 static void
889 pack_ubyte_GR88(const GLubyte src[4], void *dst)
890 {
891 GLubyte *d = ((GLubyte *) dst);
892 *d = PACK_COLOR_88(src[GCOMP], src[RCOMP]);
893 }
894
895 static void
896 pack_float_GR88(const GLfloat src[4], void *dst)
897 {
898 GLushort *d = ((GLushort *) dst);
899 GLubyte r, g;
900 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
901 UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
902 *d = PACK_COLOR_88(g, r);
903 }
904
905
906 /* MESA_FORMAT_G8R8_UNORM */
907
908 static void
909 pack_ubyte_RG88(const GLubyte src[4], void *dst)
910 {
911 GLubyte *d = ((GLubyte *) dst);
912 *d = PACK_COLOR_88(src[RCOMP], src[GCOMP]);
913 }
914
915 static void
916 pack_float_RG88(const GLfloat src[4], void *dst)
917 {
918 GLushort *d = ((GLushort *) dst);
919 GLubyte r, g;
920 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
921 UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
922 *d = PACK_COLOR_88(r, g);
923 }
924
925
926 /* MESA_FORMAT_R_UNORM16 */
927
928 static void
929 pack_ubyte_R16(const GLubyte src[4], void *dst)
930 {
931 GLushort *d = ((GLushort *) dst);
932 *d = UBYTE_TO_USHORT(src[RCOMP]);
933 }
934
935 static void
936 pack_float_R16(const GLfloat src[4], void *dst)
937 {
938 GLushort *d = ((GLushort *) dst);
939 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
940 }
941
942
943 /* MESA_FORMAT_R16G16_UNORM */
944
945 static void
946 pack_ubyte_GR1616(const GLubyte src[4], void *dst)
947 {
948 GLuint *d = ((GLuint *) dst);
949 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
950 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
951 *d = PACK_COLOR_1616(g, r);
952 }
953
954 static void
955 pack_float_GR1616(const GLfloat src[4], void *dst)
956 {
957 GLuint *d = ((GLuint *) dst);
958 GLushort r, g;
959 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
960 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
961 *d = PACK_COLOR_1616(g, r);
962 }
963
964
965 /* MESA_FORMAT_G16R16_UNORM */
966
967 static void
968 pack_ubyte_RG1616(const GLubyte src[4], void *dst)
969 {
970 GLuint *d = ((GLuint *) dst);
971 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
972 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
973 *d = PACK_COLOR_1616(r, g);
974 }
975
976
977 static void
978 pack_float_RG1616(const GLfloat src[4], void *dst)
979 {
980 GLuint *d = ((GLuint *) dst);
981 GLushort r, g;
982 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
983 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
984 *d = PACK_COLOR_1616(r, g);
985 }
986
987
988 /* MESA_FORMAT_B10G10R10A2_UNORM */
989
990 static void
991 pack_ubyte_ARGB2101010(const GLubyte src[4], void *dst)
992 {
993 GLuint *d = ((GLuint *) dst);
994 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
995 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
996 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
997 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
998 *d = PACK_COLOR_2101010_US(a, r, g, b);
999 }
1000
1001 static void
1002 pack_float_ARGB2101010(const GLfloat src[4], void *dst)
1003 {
1004 GLuint *d = ((GLuint *) dst);
1005 GLushort r, g, b, a;
1006 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1007 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1008 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1009 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1010 *d = PACK_COLOR_2101010_US(a, r, g, b);
1011 }
1012
1013
1014 /* MESA_FORMAT_R10G10B10A2_UINT */
1015
1016 static void
1017 pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst)
1018 {
1019 GLuint *d = ((GLuint *) dst);
1020 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1021 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1022 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1023 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1024 *d = PACK_COLOR_2101010_US(a, b, g, r);
1025 }
1026
1027 static void
1028 pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst)
1029 {
1030 GLuint *d = ((GLuint *) dst);
1031 GLushort r, g, b, a;
1032 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1033 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1034 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1035 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1036 *d = PACK_COLOR_2101010_US(a, b, g, r);
1037 }
1038
1039
1040 /* MESA_FORMAT_BGR_SRGB8 */
1041
1042 static void
1043 pack_ubyte_SRGB8(const GLubyte src[4], void *dst)
1044 {
1045 GLubyte *d = ((GLubyte *) dst);
1046 d[2] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1047 d[1] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1048 d[0] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1049 }
1050
1051 static void
1052 pack_float_SRGB8(const GLfloat src[4], void *dst)
1053 {
1054 GLubyte *d = ((GLubyte *) dst);
1055 d[2] = linear_float_to_srgb_ubyte(src[RCOMP]);
1056 d[1] = linear_float_to_srgb_ubyte(src[GCOMP]);
1057 d[0] = linear_float_to_srgb_ubyte(src[BCOMP]);
1058 }
1059
1060
1061 /* MESA_FORMAT_A8B8G8R8_SRGB */
1062
1063 static void
1064 pack_ubyte_SRGBA8(const GLubyte src[4], void *dst)
1065 {
1066 GLuint *d = ((GLuint *) dst);
1067 GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1068 GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1069 GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1070 *d = PACK_COLOR_8888(r, g, b, src[ACOMP]);
1071 }
1072
1073 static void
1074 pack_float_SRGBA8(const GLfloat src[4], void *dst)
1075 {
1076 GLuint *d = ((GLuint *) dst);
1077 GLubyte r, g, b, a;
1078 r = linear_float_to_srgb_ubyte(src[RCOMP]);
1079 g = linear_float_to_srgb_ubyte(src[GCOMP]);
1080 b = linear_float_to_srgb_ubyte(src[BCOMP]);
1081 UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1082 *d = PACK_COLOR_8888(r, g, b, a);
1083 }
1084
1085
1086 /* MESA_FORMAT_B8G8R8A8_SRGB */
1087
1088 static void
1089 pack_ubyte_SARGB8(const GLubyte src[4], void *dst)
1090 {
1091 GLuint *d = ((GLuint *) dst);
1092 GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1093 GLubyte g = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1094 GLubyte b = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1095 *d = PACK_COLOR_8888(src[ACOMP], r, g, b);
1096 }
1097
1098 static void
1099 pack_float_SARGB8(const GLfloat src[4], void *dst)
1100 {
1101 GLuint *d = ((GLuint *) dst);
1102 GLubyte r, g, b, a;
1103 r = linear_float_to_srgb_ubyte(src[RCOMP]);
1104 g = linear_float_to_srgb_ubyte(src[GCOMP]);
1105 b = linear_float_to_srgb_ubyte(src[BCOMP]);
1106 UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1107 *d = PACK_COLOR_8888(a, r, g, b);
1108 }
1109
1110
1111 /* MESA_FORMAT_L_SRGB8 */
1112
1113 static void
1114 pack_ubyte_SL8(const GLubyte src[4], void *dst)
1115 {
1116 GLubyte *d = ((GLubyte *) dst);
1117 *d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1118 }
1119
1120 static void
1121 pack_float_SL8(const GLfloat src[4], void *dst)
1122 {
1123 GLubyte *d = ((GLubyte *) dst);
1124 GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
1125 *d = l;
1126 }
1127
1128
1129 /* MESA_FORMAT_L8A8_SRGB */
1130
1131 static void
1132 pack_ubyte_SLA8(const GLubyte src[4], void *dst)
1133 {
1134 GLushort *d = ((GLushort *) dst);
1135 GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1136 *d = PACK_COLOR_88(src[ACOMP], l);
1137 }
1138
1139 static void
1140 pack_float_SLA8(const GLfloat src[4], void *dst)
1141 {
1142 GLushort *d = ((GLushort *) dst);
1143 GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
1144 CLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1145 *d = PACK_COLOR_88(a, l);
1146 }
1147
1148
1149 /* MESA_FORMAT_RGBA_FLOAT32 */
1150
1151 static void
1152 pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
1153 {
1154 GLfloat *d = ((GLfloat *) dst);
1155 d[0] = UBYTE_TO_FLOAT(src[0]);
1156 d[1] = UBYTE_TO_FLOAT(src[1]);
1157 d[2] = UBYTE_TO_FLOAT(src[2]);
1158 d[3] = UBYTE_TO_FLOAT(src[3]);
1159 }
1160
1161 static void
1162 pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
1163 {
1164 GLfloat *d = ((GLfloat *) dst);
1165 d[0] = src[0];
1166 d[1] = src[1];
1167 d[2] = src[2];
1168 d[3] = src[3];
1169 }
1170
1171
1172 /* MESA_FORMAT_RGBA_FLOAT16 */
1173
1174 static void
1175 pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
1176 {
1177 GLhalfARB *d = ((GLhalfARB *) dst);
1178 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1179 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1180 d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1181 d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
1182 }
1183
1184 static void
1185 pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
1186 {
1187 GLhalfARB *d = ((GLhalfARB *) dst);
1188 d[0] = _mesa_float_to_half(src[0]);
1189 d[1] = _mesa_float_to_half(src[1]);
1190 d[2] = _mesa_float_to_half(src[2]);
1191 d[3] = _mesa_float_to_half(src[3]);
1192 }
1193
1194
1195 /* MESA_FORMAT_RGB_FLOAT32 */
1196
1197 static void
1198 pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
1199 {
1200 GLfloat *d = ((GLfloat *) dst);
1201 d[0] = UBYTE_TO_FLOAT(src[0]);
1202 d[1] = UBYTE_TO_FLOAT(src[1]);
1203 d[2] = UBYTE_TO_FLOAT(src[2]);
1204 }
1205
1206 static void
1207 pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
1208 {
1209 GLfloat *d = ((GLfloat *) dst);
1210 d[0] = src[0];
1211 d[1] = src[1];
1212 d[2] = src[2];
1213 }
1214
1215
1216 /* MESA_FORMAT_RGB_FLOAT16 */
1217
1218 static void
1219 pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
1220 {
1221 GLhalfARB *d = ((GLhalfARB *) dst);
1222 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1223 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1224 d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1225 }
1226
1227 static void
1228 pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
1229 {
1230 GLhalfARB *d = ((GLhalfARB *) dst);
1231 d[0] = _mesa_float_to_half(src[0]);
1232 d[1] = _mesa_float_to_half(src[1]);
1233 d[2] = _mesa_float_to_half(src[2]);
1234 }
1235
1236
1237 /* MESA_FORMAT_A_FLOAT32 */
1238
1239 static void
1240 pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
1241 {
1242 GLfloat *d = ((GLfloat *) dst);
1243 d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
1244 }
1245
1246 static void
1247 pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
1248 {
1249 GLfloat *d = ((GLfloat *) dst);
1250 d[0] = src[ACOMP];
1251 }
1252
1253
1254 /* MESA_FORMAT_A_FLOAT16 */
1255
1256 static void
1257 pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
1258 {
1259 GLhalfARB *d = ((GLhalfARB *) dst);
1260 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1261 }
1262
1263 static void
1264 pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1265 {
1266 GLhalfARB *d = ((GLhalfARB *) dst);
1267 d[0] = _mesa_float_to_half(src[ACOMP]);
1268 }
1269
1270
1271 /* MESA_FORMAT_L_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
1272
1273 static void
1274 pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
1275 {
1276 GLfloat *d = ((GLfloat *) dst);
1277 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1278 }
1279
1280 static void
1281 pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
1282 {
1283 GLfloat *d = ((GLfloat *) dst);
1284 d[0] = src[RCOMP];
1285 }
1286
1287
1288 /* MESA_FORMAT_L_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
1289
1290 static void
1291 pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
1292 {
1293 GLhalfARB *d = ((GLhalfARB *) dst);
1294 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1295 }
1296
1297 static void
1298 pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
1299 {
1300 GLhalfARB *d = ((GLhalfARB *) dst);
1301 d[0] = _mesa_float_to_half(src[RCOMP]);
1302 }
1303
1304
1305 /* MESA_FORMAT_LA_FLOAT32 */
1306
1307 static void
1308 pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
1309 {
1310 GLfloat *d = ((GLfloat *) dst);
1311 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1312 d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
1313 }
1314
1315 static void
1316 pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
1317 {
1318 GLfloat *d = ((GLfloat *) dst);
1319 d[0] = src[RCOMP];
1320 d[1] = src[ACOMP];
1321 }
1322
1323
1324 /* MESA_FORMAT_LA_FLOAT16 */
1325
1326 static void
1327 pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
1328 {
1329 GLhalfARB *d = ((GLhalfARB *) dst);
1330 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1331 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1332 }
1333
1334 static void
1335 pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1336 {
1337 GLhalfARB *d = ((GLhalfARB *) dst);
1338 d[0] = _mesa_float_to_half(src[RCOMP]);
1339 d[1] = _mesa_float_to_half(src[ACOMP]);
1340 }
1341
1342
1343 /* MESA_FORMAT_RG_FLOAT32 */
1344
1345 static void
1346 pack_ubyte_RG_FLOAT32(const GLubyte src[4], void *dst)
1347 {
1348 GLfloat *d = ((GLfloat *) dst);
1349 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1350 d[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1351 }
1352
1353 static void
1354 pack_float_RG_FLOAT32(const GLfloat src[4], void *dst)
1355 {
1356 GLfloat *d = ((GLfloat *) dst);
1357 d[0] = src[RCOMP];
1358 d[1] = src[GCOMP];
1359 }
1360
1361
1362 /* MESA_FORMAT_RG_FLOAT16 */
1363
1364 static void
1365 pack_ubyte_RG_FLOAT16(const GLubyte src[4], void *dst)
1366 {
1367 GLhalfARB *d = ((GLhalfARB *) dst);
1368 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1369 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[GCOMP]));
1370 }
1371
1372 static void
1373 pack_float_RG_FLOAT16(const GLfloat src[4], void *dst)
1374 {
1375 GLhalfARB *d = ((GLhalfARB *) dst);
1376 d[0] = _mesa_float_to_half(src[RCOMP]);
1377 d[1] = _mesa_float_to_half(src[GCOMP]);
1378 }
1379
1380
1381 /* MESA_FORMAT_DUDV8 */
1382
1383 static void
1384 pack_ubyte_DUDV8(const GLubyte src[4], void *dst)
1385 {
1386 /* XXX is this ever used? */
1387 GLushort *d = ((GLushort *) dst);
1388 *d = PACK_COLOR_88(src[0], src[1]);
1389 }
1390
1391 static void
1392 pack_float_DUDV8(const GLfloat src[4], void *dst)
1393 {
1394 GLushort *d = ((GLushort *) dst);
1395 GLbyte du, dv;
1396 du = FLOAT_TO_BYTE(CLAMP(src[0], 0.0F, 1.0F));
1397 dv = FLOAT_TO_BYTE(CLAMP(src[1], 0.0F, 1.0F));
1398 *d = PACK_COLOR_88(du, dv);
1399 }
1400
1401
1402 /* MESA_FORMAT_RGBA_UNORM16 */
1403
1404 static void
1405 pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
1406 {
1407 GLushort *d = ((GLushort *) dst);
1408 d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1409 d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1410 d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1411 d[3] = UBYTE_TO_USHORT(src[ACOMP]);
1412 }
1413
1414 static void
1415 pack_float_RGBA_16(const GLfloat src[4], void *dst)
1416 {
1417 GLushort *d = ((GLushort *) dst);
1418 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1419 UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1420 UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1421 UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
1422 }
1423
1424
1425
1426 /*
1427 * MESA_FORMAT_R_SNORM8
1428 */
1429
1430 static void
1431 pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
1432 {
1433 GLbyte *d = (GLbyte *) dst;
1434 *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1435 }
1436
1437
1438 /*
1439 * MESA_FORMAT_R8G8_SNORM
1440 */
1441
1442 static void
1443 pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
1444 {
1445 GLushort *d = (GLushort *) dst;
1446 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1447 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1448 *d = (g << 8) | r;
1449 }
1450
1451
1452 /*
1453 * MESA_FORMAT_X8B8G8R8_SNORM
1454 */
1455
1456 static void
1457 pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
1458 {
1459 GLuint *d = (GLuint *) dst;
1460 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1461 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1462 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1463 GLbyte a = 127;
1464 *d = PACK_COLOR_8888(r, g, b, a);
1465 }
1466
1467
1468 /*
1469 * MESA_FORMAT_A8B8G8R8_SNORM
1470 */
1471
1472 static void
1473 pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
1474 {
1475 GLuint *d = (GLuint *) dst;
1476 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1477 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1478 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1479 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1480 *d = PACK_COLOR_8888(r, g, b, a);
1481 }
1482
1483
1484 /*
1485 * MESA_FORMAT_R8G8B8A8_SNORM
1486 */
1487
1488 static void
1489 pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
1490 {
1491 GLuint *d = (GLuint *) dst;
1492 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1493 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1494 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1495 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1496 *d = PACK_COLOR_8888(a, b, g, r);
1497 }
1498
1499
1500 /*
1501 * MESA_FORMAT_R_SNORM16
1502 */
1503
1504 static void
1505 pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
1506 {
1507 GLshort *d = (GLshort *) dst;
1508 *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1509 }
1510
1511
1512 /*
1513 * MESA_FORMAT_R16G16_SNORM
1514 */
1515
1516 static void
1517 pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
1518 {
1519 GLuint *d = (GLuint *) dst;
1520 GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1521 GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1522 *d = (g << 16) | (r & 0xffff);
1523 }
1524
1525
1526 /*
1527 * MESA_FORMAT_RGB_SNORM16
1528 */
1529
1530 static void
1531 pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
1532 {
1533 GLshort *d = (GLshort *) dst;
1534 d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1535 d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1536 d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1537 }
1538
1539
1540 /*
1541 * MESA_FORMAT_RGBA_SNORM16
1542 */
1543
1544 static void
1545 pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
1546 {
1547 GLshort *d = (GLshort *) dst;
1548 d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1549 d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1550 d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1551 d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1552 }
1553
1554
1555 /*
1556 * MESA_FORMAT_A_SNORM8
1557 */
1558
1559 static void
1560 pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
1561 {
1562 GLbyte *d = (GLbyte *) dst;
1563 *d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1564 }
1565
1566
1567 /*
1568 * MESA_FORMAT_L_SNORM8
1569 */
1570
1571 static void
1572 pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
1573 {
1574 GLbyte *d = (GLbyte *) dst;
1575 *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1576 }
1577
1578
1579 /*
1580 * MESA_FORMAT_L8A8_SNORM
1581 */
1582
1583 static void
1584 pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
1585 {
1586 GLushort *d = (GLushort *) dst;
1587 GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1588 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1589 *d = (a << 8) | l;
1590 }
1591
1592
1593 /*
1594 * MESA_FORMAT_A_SNORM16
1595 */
1596
1597 static void
1598 pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
1599 {
1600 GLshort *d = (GLshort *) dst;
1601 *d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1602 }
1603
1604
1605 /*
1606 * MESA_FORMAT_L_SNORM16
1607 */
1608
1609 static void
1610 pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
1611 {
1612 GLshort *d = (GLshort *) dst;
1613 *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1614 }
1615
1616
1617 /*
1618 * MESA_FORMAT_LA_SNORM16
1619 */
1620
1621 static void
1622 pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
1623 {
1624 GLuint *d = (GLuint *) dst;
1625 GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1626 GLshort a = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1627 *d = PACK_COLOR_1616(a, l);
1628 }
1629
1630
1631 /*
1632 * MESA_FORMAT_R9G9B9E5_FLOAT;
1633 */
1634
1635 static void
1636 pack_float_RGB9_E5_FLOAT(const GLfloat src[4], void *dst)
1637 {
1638 GLuint *d = (GLuint *) dst;
1639 *d = float3_to_rgb9e5(src);
1640 }
1641
1642 static void
1643 pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
1644 {
1645 GLuint *d = (GLuint *) dst;
1646 GLfloat rgb[3];
1647 rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1648 rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1649 rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1650 *d = float3_to_rgb9e5(rgb);
1651 }
1652
1653
1654
1655 /*
1656 * MESA_FORMAT_R11G11B10_FLOAT;
1657 */
1658
1659 static void
1660 pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
1661 {
1662 GLuint *d = (GLuint *) dst;
1663 GLfloat rgb[3];
1664 rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1665 rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1666 rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1667 *d = float3_to_r11g11b10f(rgb);
1668 }
1669
1670 static void
1671 pack_float_R11_G11_B10_FLOAT(const GLfloat src[4], void *dst)
1672 {
1673 GLuint *d = (GLuint *) dst;
1674 *d = float3_to_r11g11b10f(src);
1675 }
1676
1677
1678 /*
1679 * MESA_FORMAT_B4G4R4X4_UNORM
1680 */
1681
1682 static void
1683 pack_ubyte_XRGB4444_UNORM(const GLubyte src[4], void *dst)
1684 {
1685 GLushort *d = ((GLushort *) dst);
1686 *d = PACK_COLOR_4444(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1687 }
1688
1689 static void
1690 pack_float_XRGB4444_UNORM(const GLfloat src[4], void *dst)
1691 {
1692 GLubyte v[4];
1693 _mesa_unclamped_float_rgba_to_ubyte(v, src);
1694 pack_ubyte_XRGB4444_UNORM(v, dst);
1695 }
1696
1697
1698 /*
1699 * MESA_FORMAT_B5G5R5X1_UNORM
1700 */
1701
1702 static void
1703 pack_ubyte_XRGB1555_UNORM(const GLubyte src[4], void *dst)
1704 {
1705 GLushort *d = ((GLushort *) dst);
1706 *d = PACK_COLOR_1555(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1707 }
1708
1709 static void
1710 pack_float_XRGB1555_UNORM(const GLfloat src[4], void *dst)
1711 {
1712 GLubyte v[4];
1713 _mesa_unclamped_float_rgba_to_ubyte(v, src);
1714 pack_ubyte_XRGB1555_UNORM(v, dst);
1715 }
1716
1717
1718 /*
1719 * MESA_FORMAT_R8G8B8X8_SNORM
1720 */
1721
1722 static void
1723 pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
1724 {
1725 GLuint *d = (GLuint *) dst;
1726 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1727 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1728 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1729 *d = PACK_COLOR_8888(127, b, g, r);
1730 }
1731
1732
1733 /*
1734 * MESA_FORMAT_R8G8B8X8_SRGB
1735 */
1736
1737 static void
1738 pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
1739 {
1740 GLuint *d = (GLuint *) dst;
1741 GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1742 GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1743 GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1744 *d = PACK_COLOR_8888(127, b, g, r);
1745 }
1746
1747
1748 /* MESA_FORMAT_B10G10R10X2_UNORM */
1749
1750 static void
1751 pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
1752 {
1753 GLuint *d = ((GLuint *) dst);
1754 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1755 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1756 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1757 *d = PACK_COLOR_2101010_US(3, r, g, b);
1758 }
1759
1760 static void
1761 pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
1762 {
1763 GLuint *d = ((GLuint *) dst);
1764 GLushort r, g, b;
1765 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1766 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1767 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1768 *d = PACK_COLOR_2101010_US(3, r, g, b);
1769 }
1770
1771
1772 /* MESA_FORMAT_RGBX_UNORM16 */
1773
1774 static void
1775 pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
1776 {
1777 GLushort *d = ((GLushort *) dst);
1778 d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1779 d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1780 d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1781 d[3] = 65535;
1782 }
1783
1784 static void
1785 pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
1786 {
1787 GLushort *d = ((GLushort *) dst);
1788 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1789 UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1790 UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1791 d[3] = 65535;
1792 }
1793
1794
1795 /* MESA_FORMAT_RGBX_SNORM16 */
1796
1797 static void
1798 pack_float_XBGR16161616_SNORM(const GLfloat src[4], void *dst)
1799 {
1800 GLushort *d = ((GLushort *) dst);
1801 UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
1802 UNCLAMPED_FLOAT_TO_SHORT(d[1], src[GCOMP]);
1803 UNCLAMPED_FLOAT_TO_SHORT(d[2], src[BCOMP]);
1804 d[3] = 32767;
1805 }
1806
1807
1808 /* MESA_FORMAT_RGBX_FLOAT16 */
1809
1810 static void
1811 pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
1812 {
1813 GLushort *d = ((GLushort *) dst);
1814 d[0] = _mesa_float_to_half(src[RCOMP]);
1815 d[1] = _mesa_float_to_half(src[GCOMP]);
1816 d[2] = _mesa_float_to_half(src[BCOMP]);
1817 d[3] = _mesa_float_to_half(1.0);
1818 }
1819
1820 /* MESA_FORMAT_RGBX_FLOAT32 */
1821
1822 static void
1823 pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
1824 {
1825 GLfloat *d = ((GLfloat *) dst);
1826 d[0] = src[RCOMP];
1827 d[1] = src[GCOMP];
1828 d[2] = src[BCOMP];
1829 d[3] = 1.0;
1830 }
1831
1832 /* MESA_FORMAT_R10G10B10A2_UNORM */
1833
1834 static void
1835 pack_ubyte_ABGR2101010(const GLubyte src[4], void *dst)
1836 {
1837 GLuint *d = ((GLuint *) dst);
1838 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1839 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1840 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1841 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1842 *d = PACK_COLOR_2101010_US(a, b, g, r);
1843 }
1844
1845 static void
1846 pack_float_ABGR2101010(const GLfloat src[4], void *dst)
1847 {
1848 GLuint *d = ((GLuint *) dst);
1849 GLushort r, g, b, a;
1850 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1851 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1852 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1853 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1854 *d = PACK_COLOR_2101010_US(a, b, g, r);
1855 }
1856
1857 /*
1858 * MESA_FORMAT_G8R8_SNORM
1859 */
1860
1861 static void
1862 pack_float_SIGNED_RG88(const GLfloat src[4], void *dst)
1863 {
1864 GLushort *d = (GLushort *) dst;
1865 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1866 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1867 *d = (r << 8) | (g & 0xff);
1868 }
1869
1870 /*
1871 * MESA_FORMAT_G16R16_SNORM
1872 */
1873
1874 static void
1875 pack_float_SIGNED_RG1616(const GLfloat src[4], void *dst)
1876 {
1877 GLuint *d = (GLuint *) dst;
1878 GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1879 GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1880 *d = (r << 16) | (g & 0xffff);
1881 }
1882
1883 /*
1884 * MESA_FORMAT_B8G8R8X8_SRGB
1885 */
1886
1887 static void
1888 pack_float_XRGB8888_SRGB(const GLfloat src[4], void *dst)
1889 {
1890 GLuint *d = (GLuint *) dst;
1891 GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1892 GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1893 GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1894 *d = PACK_COLOR_8888(127, r, g, b);
1895 }
1896
1897 /**
1898 * Return a function that can pack a GLubyte rgba[4] color.
1899 */
1900 gl_pack_ubyte_rgba_func
1901 _mesa_get_pack_ubyte_rgba_function(mesa_format format)
1902 {
1903 static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
1904 static GLboolean initialized = GL_FALSE;
1905
1906 if (!initialized) {
1907 memset(table, 0, sizeof(table));
1908
1909 table[MESA_FORMAT_NONE] = NULL;
1910
1911 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_ubyte_RGBA8888;
1912 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_ubyte_RGBA8888_REV;
1913 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_ubyte_ARGB8888;
1914 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_ubyte_ARGB8888_REV;
1915 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_ubyte_RGBA8888; /* reused */
1916 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_ubyte_RGBA8888_REV; /* reused */
1917 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_ubyte_XRGB8888;
1918 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_ubyte_XRGB8888_REV;
1919 table[MESA_FORMAT_BGR_UNORM8] = pack_ubyte_RGB888;
1920 table[MESA_FORMAT_RGB_UNORM8] = pack_ubyte_BGR888;
1921 table[MESA_FORMAT_B5G6R5_UNORM] = pack_ubyte_RGB565;
1922 table[MESA_FORMAT_R5G6B5_UNORM] = pack_ubyte_RGB565_REV;
1923 table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_ubyte_ARGB4444;
1924 table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_ubyte_ARGB4444_REV;
1925 table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_ubyte_RGBA5551;
1926 table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_ubyte_ARGB1555;
1927 table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_ubyte_ARGB1555_REV;
1928 table[MESA_FORMAT_L4A4_UNORM] = pack_ubyte_AL44;
1929 table[MESA_FORMAT_L8A8_UNORM] = pack_ubyte_AL88;
1930 table[MESA_FORMAT_A8L8_UNORM] = pack_ubyte_AL88_REV;
1931 table[MESA_FORMAT_L16A16_UNORM] = pack_ubyte_AL1616;
1932 table[MESA_FORMAT_A16L16_UNORM] = pack_ubyte_AL1616_REV;
1933 table[MESA_FORMAT_B2G3R3_UNORM] = pack_ubyte_RGB332;
1934 table[MESA_FORMAT_A_UNORM8] = pack_ubyte_A8;
1935 table[MESA_FORMAT_A_UNORM16] = pack_ubyte_A16;
1936 table[MESA_FORMAT_L_UNORM8] = pack_ubyte_L8;
1937 table[MESA_FORMAT_L_UNORM16] = pack_ubyte_L16;
1938 table[MESA_FORMAT_I_UNORM8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
1939 table[MESA_FORMAT_I_UNORM16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
1940 table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
1941 table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
1942 table[MESA_FORMAT_R_UNORM8] = pack_ubyte_R8;
1943 table[MESA_FORMAT_R8G8_UNORM] = pack_ubyte_GR88;
1944 table[MESA_FORMAT_G8R8_UNORM] = pack_ubyte_RG88;
1945 table[MESA_FORMAT_R_UNORM16] = pack_ubyte_R16;
1946 table[MESA_FORMAT_R16G16_UNORM] = pack_ubyte_GR1616;
1947 table[MESA_FORMAT_G16R16_UNORM] = pack_ubyte_RG1616;
1948 table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_ubyte_ARGB2101010;
1949 table[MESA_FORMAT_R10G10B10A2_UINT] = pack_ubyte_ABGR2101010_UINT;
1950
1951 /* should never convert RGBA to these formats */
1952 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
1953 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
1954 table[MESA_FORMAT_Z_UNORM16] = NULL;
1955 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
1956 table[MESA_FORMAT_X8Z24_UNORM] = NULL;
1957 table[MESA_FORMAT_Z_UNORM32] = NULL;
1958 table[MESA_FORMAT_S_UINT8] = NULL;
1959
1960 /* sRGB */
1961 table[MESA_FORMAT_BGR_SRGB8] = pack_ubyte_SRGB8;
1962 table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_ubyte_SRGBA8;
1963 table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_ubyte_SARGB8;
1964 table[MESA_FORMAT_L_SRGB8] = pack_ubyte_SL8;
1965 table[MESA_FORMAT_L8A8_SRGB] = pack_ubyte_SLA8;
1966 /* n/a */
1967 table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
1968 table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
1969 table[MESA_FORMAT_SRGBA_DXT3] = NULL; /* pack_ubyte_SRGBA_DXT3; */
1970 table[MESA_FORMAT_SRGBA_DXT5] = NULL; /* pack_ubyte_SRGBA_DXT5; */
1971
1972 table[MESA_FORMAT_RGB_FXT1] = NULL; /* pack_ubyte_RGB_FXT1; */
1973 table[MESA_FORMAT_RGBA_FXT1] = NULL; /* pack_ubyte_RGBA_FXT1; */
1974 table[MESA_FORMAT_RGB_DXT1] = NULL; /* pack_ubyte_RGB_DXT1; */
1975 table[MESA_FORMAT_RGBA_DXT1] = NULL; /* pack_ubyte_RGBA_DXT1; */
1976 table[MESA_FORMAT_RGBA_DXT3] = NULL; /* pack_ubyte_RGBA_DXT3; */
1977 table[MESA_FORMAT_RGBA_DXT5] = NULL; /* pack_ubyte_RGBA_DXT5; */
1978
1979 table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
1980 table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
1981 table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
1982 table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
1983 table[MESA_FORMAT_A_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
1984 table[MESA_FORMAT_A_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
1985 table[MESA_FORMAT_L_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1986 table[MESA_FORMAT_L_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1987 table[MESA_FORMAT_LA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
1988 table[MESA_FORMAT_LA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
1989 table[MESA_FORMAT_I_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1990 table[MESA_FORMAT_I_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1991 table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
1992 table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
1993 table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
1994 table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
1995
1996 /* n/a */
1997 table[MESA_FORMAT_RGBA_SINT8] = NULL; /* pack_ubyte_RGBA_INT8 */
1998 table[MESA_FORMAT_RGBA_SINT16] = NULL; /* pack_ubyte_RGBA_INT16 */
1999 table[MESA_FORMAT_RGBA_SINT32] = NULL; /* pack_ubyte_RGBA_INT32 */
2000 table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
2001 table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
2002 table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
2003
2004 table[MESA_FORMAT_DUDV8] = pack_ubyte_DUDV8;
2005
2006 table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2007
2008 /* n/a */
2009 table[MESA_FORMAT_R_SNORM8] = NULL;
2010 table[MESA_FORMAT_R8G8_SNORM] = NULL;
2011 table[MESA_FORMAT_X8B8G8R8_SNORM] = NULL;
2012 table[MESA_FORMAT_A8B8G8R8_SNORM] = NULL;
2013 table[MESA_FORMAT_R8G8B8A8_SNORM] = NULL;
2014 table[MESA_FORMAT_R_SNORM16] = NULL;
2015 table[MESA_FORMAT_R16G16_SNORM] = NULL;
2016 table[MESA_FORMAT_RGB_SNORM16] = NULL;
2017 table[MESA_FORMAT_RGBA_SNORM16] = NULL;
2018 table[MESA_FORMAT_A_SNORM8] = NULL;
2019 table[MESA_FORMAT_L_SNORM8] = NULL;
2020 table[MESA_FORMAT_L8A8_SNORM] = NULL;
2021 table[MESA_FORMAT_I_SNORM8] = NULL;
2022 table[MESA_FORMAT_A_SNORM16] = NULL;
2023 table[MESA_FORMAT_L_SNORM16] = NULL;
2024 table[MESA_FORMAT_LA_SNORM16] = NULL;
2025 table[MESA_FORMAT_I_SNORM16] = NULL;
2026
2027
2028 table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2029
2030 table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_ubyte_RGB9_E5_FLOAT;
2031 table[MESA_FORMAT_R11G11B10_FLOAT] = pack_ubyte_R11_G11_B10_FLOAT;
2032
2033 table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_ubyte_XRGB4444_UNORM;
2034 table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_ubyte_XRGB1555_UNORM;
2035 table[MESA_FORMAT_R8G8B8X8_SNORM] = NULL;
2036 table[MESA_FORMAT_R8G8B8X8_SRGB] = NULL;
2037 table[MESA_FORMAT_RGBX_UINT8] = NULL;
2038 table[MESA_FORMAT_RGBX_SINT8] = NULL;
2039 table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_ubyte_XRGB2101010_UNORM;
2040 table[MESA_FORMAT_RGBX_UNORM16] = pack_ubyte_XBGR16161616_UNORM;
2041 table[MESA_FORMAT_RGBX_SNORM16] = NULL;
2042 table[MESA_FORMAT_RGBX_FLOAT16] = NULL;
2043 table[MESA_FORMAT_RGBX_UINT16] = NULL;
2044 table[MESA_FORMAT_RGBX_SINT16] = NULL;
2045 table[MESA_FORMAT_RGBX_FLOAT32] = NULL;
2046 table[MESA_FORMAT_RGBX_UINT32] = NULL;
2047 table[MESA_FORMAT_RGBX_SINT32] = NULL;
2048
2049 table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_ubyte_ABGR2101010;
2050
2051 table[MESA_FORMAT_B8G8R8X8_SRGB] = NULL;
2052
2053 initialized = GL_TRUE;
2054 }
2055
2056 return table[format];
2057 }
2058
2059
2060
2061 /**
2062 * Return a function that can pack a GLfloat rgba[4] color.
2063 */
2064 gl_pack_float_rgba_func
2065 _mesa_get_pack_float_rgba_function(mesa_format format)
2066 {
2067 static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
2068 static GLboolean initialized = GL_FALSE;
2069
2070 if (!initialized) {
2071 memset(table, 0, sizeof(table));
2072
2073 table[MESA_FORMAT_NONE] = NULL;
2074
2075 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_float_RGBA8888;
2076 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_float_RGBA8888_REV;
2077 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_float_ARGB8888;
2078 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_float_ARGB8888_REV;
2079 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_float_RGBA8888; /* reused */
2080 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_float_RGBA8888_REV; /* reused */
2081 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_float_XRGB8888;
2082 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_float_XRGB8888_REV;
2083 table[MESA_FORMAT_BGR_UNORM8] = pack_float_RGB888;
2084 table[MESA_FORMAT_RGB_UNORM8] = pack_float_BGR888;
2085 table[MESA_FORMAT_B5G6R5_UNORM] = pack_float_RGB565;
2086 table[MESA_FORMAT_R5G6B5_UNORM] = pack_float_RGB565_REV;
2087 table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_float_ARGB4444;
2088 table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_float_ARGB4444_REV;
2089 table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_float_RGBA5551;
2090 table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_float_ARGB1555;
2091 table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_float_ARGB1555_REV;
2092
2093 table[MESA_FORMAT_L4A4_UNORM] = pack_float_AL44;
2094 table[MESA_FORMAT_L8A8_UNORM] = pack_float_AL88;
2095 table[MESA_FORMAT_A8L8_UNORM] = pack_float_AL88_REV;
2096 table[MESA_FORMAT_L16A16_UNORM] = pack_float_AL1616;
2097 table[MESA_FORMAT_A16L16_UNORM] = pack_float_AL1616_REV;
2098 table[MESA_FORMAT_B2G3R3_UNORM] = pack_float_RGB332;
2099 table[MESA_FORMAT_A_UNORM8] = pack_float_A8;
2100 table[MESA_FORMAT_A_UNORM16] = pack_float_A16;
2101 table[MESA_FORMAT_L_UNORM8] = pack_float_L8;
2102 table[MESA_FORMAT_L_UNORM16] = pack_float_L16;
2103 table[MESA_FORMAT_I_UNORM8] = pack_float_L8; /* reuse pack_float_L8 */
2104 table[MESA_FORMAT_I_UNORM16] = pack_float_L16; /* reuse pack_float_L16 */
2105 table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
2106 table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
2107 table[MESA_FORMAT_R_UNORM8] = pack_float_R8;
2108 table[MESA_FORMAT_R8G8_UNORM] = pack_float_GR88;
2109 table[MESA_FORMAT_G8R8_UNORM] = pack_float_RG88;
2110 table[MESA_FORMAT_R_UNORM16] = pack_float_R16;
2111 table[MESA_FORMAT_R16G16_UNORM] = pack_float_GR1616;
2112 table[MESA_FORMAT_G16R16_UNORM] = pack_float_RG1616;
2113 table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_float_ARGB2101010;
2114 table[MESA_FORMAT_R10G10B10A2_UINT] = pack_float_ABGR2101010_UINT;
2115
2116 /* should never convert RGBA to these formats */
2117 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
2118 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
2119 table[MESA_FORMAT_Z_UNORM16] = NULL;
2120 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
2121 table[MESA_FORMAT_X8Z24_UNORM] = NULL;
2122 table[MESA_FORMAT_Z_UNORM32] = NULL;
2123 table[MESA_FORMAT_S_UINT8] = NULL;
2124
2125 table[MESA_FORMAT_BGR_SRGB8] = pack_float_SRGB8;
2126 table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_float_SRGBA8;
2127 table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_float_SARGB8;
2128 table[MESA_FORMAT_L_SRGB8] = pack_float_SL8;
2129 table[MESA_FORMAT_L8A8_SRGB] = pack_float_SLA8;
2130
2131 /* n/a */
2132 table[MESA_FORMAT_SRGB_DXT1] = NULL;
2133 table[MESA_FORMAT_SRGBA_DXT1] = NULL;
2134 table[MESA_FORMAT_SRGBA_DXT3] = NULL;
2135 table[MESA_FORMAT_SRGBA_DXT5] = NULL;
2136
2137 table[MESA_FORMAT_RGB_FXT1] = NULL;
2138 table[MESA_FORMAT_RGBA_FXT1] = NULL;
2139 table[MESA_FORMAT_RGB_DXT1] = NULL;
2140 table[MESA_FORMAT_RGBA_DXT1] = NULL;
2141 table[MESA_FORMAT_RGBA_DXT3] = NULL;
2142 table[MESA_FORMAT_RGBA_DXT5] = NULL;
2143
2144 table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
2145 table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
2146 table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
2147 table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
2148 table[MESA_FORMAT_A_FLOAT32] = pack_float_ALPHA_FLOAT32;
2149 table[MESA_FORMAT_A_FLOAT16] = pack_float_ALPHA_FLOAT16;
2150 table[MESA_FORMAT_L_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2151 table[MESA_FORMAT_L_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2152 table[MESA_FORMAT_LA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
2153 table[MESA_FORMAT_LA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
2154
2155 table[MESA_FORMAT_I_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2156 table[MESA_FORMAT_I_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2157 table[MESA_FORMAT_R_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2158 table[MESA_FORMAT_R_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2159 table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
2160 table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
2161
2162 /* n/a */
2163 table[MESA_FORMAT_RGBA_SINT8] = NULL;
2164 table[MESA_FORMAT_RGBA_SINT16] = NULL;
2165 table[MESA_FORMAT_RGBA_SINT32] = NULL;
2166 table[MESA_FORMAT_RGBA_UINT8] = NULL;
2167 table[MESA_FORMAT_RGBA_UINT16] = NULL;
2168 table[MESA_FORMAT_RGBA_UINT32] = NULL;
2169
2170 table[MESA_FORMAT_DUDV8] = pack_float_DUDV8;
2171
2172 table[MESA_FORMAT_RGBA_UNORM16] = pack_float_RGBA_16;
2173
2174 table[MESA_FORMAT_R_SNORM8] = pack_float_SIGNED_R8;
2175 table[MESA_FORMAT_R8G8_SNORM] = pack_float_SIGNED_RG88_REV;
2176 table[MESA_FORMAT_X8B8G8R8_SNORM] = pack_float_SIGNED_RGBX8888;
2177 table[MESA_FORMAT_A8B8G8R8_SNORM] = pack_float_SIGNED_RGBA8888;
2178 table[MESA_FORMAT_R8G8B8A8_SNORM] = pack_float_SIGNED_RGBA8888_REV;
2179 table[MESA_FORMAT_R_SNORM16] = pack_float_SIGNED_R16;
2180 table[MESA_FORMAT_R16G16_SNORM] = pack_float_SIGNED_GR1616;
2181 table[MESA_FORMAT_RGB_SNORM16] = pack_float_SIGNED_RGB_16;
2182 table[MESA_FORMAT_RGBA_SNORM16] = pack_float_SIGNED_RGBA_16;
2183 table[MESA_FORMAT_A_SNORM8] = pack_float_SIGNED_A8;
2184 table[MESA_FORMAT_L_SNORM8] = pack_float_SIGNED_L8;
2185 table[MESA_FORMAT_L8A8_SNORM] = pack_float_SIGNED_AL88;
2186 table[MESA_FORMAT_I_SNORM8] = pack_float_SIGNED_L8; /* reused */
2187 table[MESA_FORMAT_A_SNORM16] = pack_float_SIGNED_A16;
2188 table[MESA_FORMAT_L_SNORM16] = pack_float_SIGNED_L16;
2189 table[MESA_FORMAT_LA_SNORM16] = pack_float_SIGNED_AL1616;
2190 table[MESA_FORMAT_I_SNORM16] = pack_float_SIGNED_L16; /* reused */
2191
2192 table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_float_RGB9_E5_FLOAT;
2193 table[MESA_FORMAT_R11G11B10_FLOAT] = pack_float_R11_G11_B10_FLOAT;
2194
2195 table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_float_XRGB4444_UNORM;
2196 table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_float_XRGB1555_UNORM;
2197 table[MESA_FORMAT_R8G8B8X8_SNORM] = pack_float_XBGR8888_SNORM;
2198 table[MESA_FORMAT_R8G8B8X8_SRGB] = pack_float_XBGR8888_SRGB;
2199 table[MESA_FORMAT_RGBX_UINT8] = NULL;
2200 table[MESA_FORMAT_RGBX_SINT8] = NULL;
2201 table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_float_XRGB2101010_UNORM;
2202 table[MESA_FORMAT_RGBX_UNORM16] = pack_float_XBGR16161616_UNORM;
2203 table[MESA_FORMAT_RGBX_SNORM16] = pack_float_XBGR16161616_SNORM;
2204 table[MESA_FORMAT_RGBX_FLOAT16] = pack_float_XBGR16161616_FLOAT;
2205 table[MESA_FORMAT_RGBX_UINT16] = NULL;
2206 table[MESA_FORMAT_RGBX_SINT16] = NULL;
2207 table[MESA_FORMAT_RGBX_FLOAT32] = pack_float_XBGR32323232_FLOAT;
2208 table[MESA_FORMAT_RGBX_UINT32] = NULL;
2209 table[MESA_FORMAT_RGBX_SINT32] = NULL;
2210
2211 table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_float_ABGR2101010;
2212
2213 table[MESA_FORMAT_G8R8_SNORM] = pack_float_SIGNED_RG88;
2214 table[MESA_FORMAT_G16R16_SNORM] = pack_float_SIGNED_RG1616;
2215
2216 table[MESA_FORMAT_B8G8R8X8_SRGB] = pack_float_XRGB8888_SRGB;
2217
2218 initialized = GL_TRUE;
2219 }
2220
2221 return table[format];
2222 }
2223
2224
2225
2226 static pack_float_rgba_row_func
2227 get_pack_float_rgba_row_function(mesa_format format)
2228 {
2229 static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
2230 static GLboolean initialized = GL_FALSE;
2231
2232 if (!initialized) {
2233 /* We don't need a special row packing function for each format.
2234 * There's a generic fallback which uses a per-pixel packing function.
2235 */
2236 memset(table, 0, sizeof(table));
2237
2238 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_float_RGBA8888;
2239 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_float_RGBA8888_REV;
2240 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_float_ARGB8888;
2241 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_float_ARGB8888_REV;
2242 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_float_RGBA8888; /* reused */
2243 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_float_RGBA8888_REV; /* reused */
2244 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_float_XRGB8888;
2245 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_float_XRGB8888_REV;
2246 table[MESA_FORMAT_BGR_UNORM8] = pack_row_float_RGB888;
2247 table[MESA_FORMAT_RGB_UNORM8] = pack_row_float_BGR888;
2248 table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_float_RGB565;
2249 table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_float_RGB565_REV;
2250
2251 initialized = GL_TRUE;
2252 }
2253
2254 return table[format];
2255 }
2256
2257
2258
2259 static pack_ubyte_rgba_row_func
2260 get_pack_ubyte_rgba_row_function(mesa_format format)
2261 {
2262 static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
2263 static GLboolean initialized = GL_FALSE;
2264
2265 if (!initialized) {
2266 /* We don't need a special row packing function for each format.
2267 * There's a generic fallback which uses a per-pixel packing function.
2268 */
2269 memset(table, 0, sizeof(table));
2270
2271 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888;
2272 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_ubyte_RGBA8888_REV;
2273 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_ubyte_ARGB8888;
2274 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_ubyte_ARGB8888_REV;
2275 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888; /* reused */
2276 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_ubyte_RGBA8888_REV; /* reused */
2277 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_ubyte_XRGB8888;
2278 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_ubyte_XRGB8888_REV;
2279 table[MESA_FORMAT_BGR_UNORM8] = pack_row_ubyte_RGB888;
2280 table[MESA_FORMAT_RGB_UNORM8] = pack_row_ubyte_BGR888;
2281 table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_ubyte_RGB565;
2282 table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_ubyte_RGB565_REV;
2283
2284 initialized = GL_TRUE;
2285 }
2286
2287 return table[format];
2288 }
2289
2290
2291
2292 /**
2293 * Pack a row of GLfloat rgba[4] values to the destination.
2294 */
2295 void
2296 _mesa_pack_float_rgba_row(mesa_format format, GLuint n,
2297 const GLfloat src[][4], void *dst)
2298 {
2299 pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
2300 if (packrow) {
2301 /* use "fast" function */
2302 packrow(n, src, dst);
2303 }
2304 else {
2305 /* slower fallback */
2306 gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
2307 GLuint dstStride = _mesa_get_format_bytes(format);
2308 GLubyte *dstPtr = (GLubyte *) dst;
2309 GLuint i;
2310
2311 assert(pack);
2312 if (!pack)
2313 return;
2314
2315 for (i = 0; i < n; i++) {
2316 pack(src[i], dstPtr);
2317 dstPtr += dstStride;
2318 }
2319 }
2320 }
2321
2322
2323 /**
2324 * Pack a row of GLubyte rgba[4] values to the destination.
2325 */
2326 void
2327 _mesa_pack_ubyte_rgba_row(mesa_format format, GLuint n,
2328 const GLubyte src[][4], void *dst)
2329 {
2330 pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2331 if (packrow) {
2332 /* use "fast" function */
2333 packrow(n, src, dst);
2334 }
2335 else {
2336 /* slower fallback */
2337 gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
2338 const GLuint stride = _mesa_get_format_bytes(format);
2339 GLubyte *d = ((GLubyte *) dst);
2340 GLuint i;
2341
2342 assert(pack);
2343 if (!pack)
2344 return;
2345
2346 for (i = 0; i < n; i++) {
2347 pack(src[i], d);
2348 d += stride;
2349 }
2350 }
2351 }
2352
2353
2354 /**
2355 * Pack a 2D image of ubyte RGBA pixels in the given format.
2356 * \param srcRowStride source image row stride in bytes
2357 * \param dstRowStride destination image row stride in bytes
2358 */
2359 void
2360 _mesa_pack_ubyte_rgba_rect(mesa_format format, GLuint width, GLuint height,
2361 const GLubyte *src, GLint srcRowStride,
2362 void *dst, GLint dstRowStride)
2363 {
2364 pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2365 GLubyte *dstUB = (GLubyte *) dst;
2366 GLuint i;
2367
2368 if (packrow) {
2369 if (srcRowStride == width * 4 * sizeof(GLubyte) &&
2370 dstRowStride == _mesa_format_row_stride(format, width)) {
2371 /* do whole image at once */
2372 packrow(width * height, (const GLubyte (*)[4]) src, dst);
2373 }
2374 else {
2375 /* row by row */
2376 for (i = 0; i < height; i++) {
2377 packrow(width, (const GLubyte (*)[4]) src, dstUB);
2378 src += srcRowStride;
2379 dstUB += dstRowStride;
2380 }
2381 }
2382 }
2383 else {
2384 /* slower fallback */
2385 for (i = 0; i < height; i++) {
2386 _mesa_pack_ubyte_rgba_row(format, width,
2387 (const GLubyte (*)[4]) src, dstUB);
2388 src += srcRowStride;
2389 dstUB += dstRowStride;
2390 }
2391 }
2392 }
2393
2394
2395
2396 /**
2397 ** Pack float Z pixels
2398 **/
2399
2400 static void
2401 pack_float_z_Z24_S8(const GLfloat *src, void *dst)
2402 {
2403 /* don't disturb the stencil values */
2404 GLuint *d = ((GLuint *) dst);
2405 const GLdouble scale = (GLdouble) 0xffffff;
2406 GLuint s = *d & 0xff;
2407 GLuint z = (GLuint) (*src * scale);
2408 assert(z <= 0xffffff);
2409 *d = (z << 8) | s;
2410 }
2411
2412 static void
2413 pack_float_z_S8_Z24(const GLfloat *src, void *dst)
2414 {
2415 /* don't disturb the stencil values */
2416 GLuint *d = ((GLuint *) dst);
2417 const GLdouble scale = (GLdouble) 0xffffff;
2418 GLuint s = *d & 0xff000000;
2419 GLuint z = (GLuint) (*src * scale);
2420 assert(z <= 0xffffff);
2421 *d = s | z;
2422 }
2423
2424 static void
2425 pack_float_z_Z16(const GLfloat *src, void *dst)
2426 {
2427 GLushort *d = ((GLushort *) dst);
2428 const GLfloat scale = (GLfloat) 0xffff;
2429 *d = (GLushort) (*src * scale);
2430 }
2431
2432 static void
2433 pack_float_z_Z32(const GLfloat *src, void *dst)
2434 {
2435 GLuint *d = ((GLuint *) dst);
2436 const GLdouble scale = (GLdouble) 0xffffffff;
2437 *d = (GLuint) (*src * scale);
2438 }
2439
2440 static void
2441 pack_float_z_Z32_FLOAT(const GLfloat *src, void *dst)
2442 {
2443 GLfloat *d = (GLfloat *) dst;
2444 *d = *src;
2445 }
2446
2447 gl_pack_float_z_func
2448 _mesa_get_pack_float_z_func(mesa_format format)
2449 {
2450 switch (format) {
2451 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2452 case MESA_FORMAT_X8Z24_UNORM:
2453 return pack_float_z_Z24_S8;
2454 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2455 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2456 return pack_float_z_S8_Z24;
2457 case MESA_FORMAT_Z_UNORM16:
2458 return pack_float_z_Z16;
2459 case MESA_FORMAT_Z_UNORM32:
2460 return pack_float_z_Z32;
2461 case MESA_FORMAT_Z_FLOAT32:
2462 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2463 return pack_float_z_Z32_FLOAT;
2464 default:
2465 _mesa_problem(NULL,
2466 "unexpected format in _mesa_get_pack_float_z_func()");
2467 return NULL;
2468 }
2469 }
2470
2471
2472
2473 /**
2474 ** Pack uint Z pixels. The incoming src value is always in
2475 ** the range [0, 2^32-1].
2476 **/
2477
2478 static void
2479 pack_uint_z_Z24_S8(const GLuint *src, void *dst)
2480 {
2481 /* don't disturb the stencil values */
2482 GLuint *d = ((GLuint *) dst);
2483 GLuint s = *d & 0xff;
2484 GLuint z = *src & 0xffffff00;
2485 *d = z | s;
2486 }
2487
2488 static void
2489 pack_uint_z_S8_Z24(const GLuint *src, void *dst)
2490 {
2491 /* don't disturb the stencil values */
2492 GLuint *d = ((GLuint *) dst);
2493 GLuint s = *d & 0xff000000;
2494 GLuint z = *src >> 8;
2495 *d = s | z;
2496 }
2497
2498 static void
2499 pack_uint_z_Z16(const GLuint *src, void *dst)
2500 {
2501 GLushort *d = ((GLushort *) dst);
2502 *d = *src >> 16;
2503 }
2504
2505 static void
2506 pack_uint_z_Z32(const GLuint *src, void *dst)
2507 {
2508 GLuint *d = ((GLuint *) dst);
2509 *d = *src;
2510 }
2511
2512 static void
2513 pack_uint_z_Z32_FLOAT(const GLuint *src, void *dst)
2514 {
2515 GLuint *d = ((GLuint *) dst);
2516 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2517 *d = (GLuint) (*src * scale);
2518 assert(*d >= 0.0f);
2519 assert(*d <= 1.0f);
2520 }
2521
2522 static void
2523 pack_uint_z_Z32_FLOAT_X24S8(const GLuint *src, void *dst)
2524 {
2525 GLfloat *d = ((GLfloat *) dst);
2526 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2527 *d = (GLfloat) (*src * scale);
2528 assert(*d >= 0.0f);
2529 assert(*d <= 1.0f);
2530 }
2531
2532 gl_pack_uint_z_func
2533 _mesa_get_pack_uint_z_func(mesa_format format)
2534 {
2535 switch (format) {
2536 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2537 case MESA_FORMAT_X8Z24_UNORM:
2538 return pack_uint_z_Z24_S8;
2539 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2540 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2541 return pack_uint_z_S8_Z24;
2542 case MESA_FORMAT_Z_UNORM16:
2543 return pack_uint_z_Z16;
2544 case MESA_FORMAT_Z_UNORM32:
2545 return pack_uint_z_Z32;
2546 case MESA_FORMAT_Z_FLOAT32:
2547 return pack_uint_z_Z32_FLOAT;
2548 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2549 return pack_uint_z_Z32_FLOAT_X24S8;
2550 default:
2551 _mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
2552 return NULL;
2553 }
2554 }
2555
2556
2557 /**
2558 ** Pack ubyte stencil pixels
2559 **/
2560
2561 static void
2562 pack_ubyte_stencil_Z24_S8(const GLubyte *src, void *dst)
2563 {
2564 /* don't disturb the Z values */
2565 GLuint *d = ((GLuint *) dst);
2566 GLuint s = *src;
2567 GLuint z = *d & 0xffffff00;
2568 *d = z | s;
2569 }
2570
2571 static void
2572 pack_ubyte_stencil_S8_Z24(const GLubyte *src, void *dst)
2573 {
2574 /* don't disturb the Z values */
2575 GLuint *d = ((GLuint *) dst);
2576 GLuint s = *src << 24;
2577 GLuint z = *d & 0xffffff;
2578 *d = s | z;
2579 }
2580
2581 static void
2582 pack_ubyte_stencil_S8(const GLubyte *src, void *dst)
2583 {
2584 GLubyte *d = (GLubyte *) dst;
2585 *d = *src;
2586 }
2587
2588 static void
2589 pack_ubyte_stencil_Z32_FLOAT_X24S8(const GLubyte *src, void *dst)
2590 {
2591 GLfloat *d = ((GLfloat *) dst);
2592 d[1] = *src;
2593 }
2594
2595
2596 gl_pack_ubyte_stencil_func
2597 _mesa_get_pack_ubyte_stencil_func(mesa_format format)
2598 {
2599 switch (format) {
2600 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2601 return pack_ubyte_stencil_Z24_S8;
2602 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2603 return pack_ubyte_stencil_S8_Z24;
2604 case MESA_FORMAT_S_UINT8:
2605 return pack_ubyte_stencil_S8;
2606 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2607 return pack_ubyte_stencil_Z32_FLOAT_X24S8;
2608 default:
2609 _mesa_problem(NULL,
2610 "unexpected format in _mesa_pack_ubyte_stencil_func()");
2611 return NULL;
2612 }
2613 }
2614
2615
2616
2617 void
2618 _mesa_pack_float_z_row(mesa_format format, GLuint n,
2619 const GLfloat *src, void *dst)
2620 {
2621 switch (format) {
2622 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2623 case MESA_FORMAT_X8Z24_UNORM:
2624 {
2625 /* don't disturb the stencil values */
2626 GLuint *d = ((GLuint *) dst);
2627 const GLdouble scale = (GLdouble) 0xffffff;
2628 GLuint i;
2629 for (i = 0; i < n; i++) {
2630 GLuint s = d[i] & 0xff;
2631 GLuint z = (GLuint) (src[i] * scale);
2632 assert(z <= 0xffffff);
2633 d[i] = (z << 8) | s;
2634 }
2635 }
2636 break;
2637 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2638 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2639 {
2640 /* don't disturb the stencil values */
2641 GLuint *d = ((GLuint *) dst);
2642 const GLdouble scale = (GLdouble) 0xffffff;
2643 GLuint i;
2644 for (i = 0; i < n; i++) {
2645 GLuint s = d[i] & 0xff000000;
2646 GLuint z = (GLuint) (src[i] * scale);
2647 assert(z <= 0xffffff);
2648 d[i] = s | z;
2649 }
2650 }
2651 break;
2652 case MESA_FORMAT_Z_UNORM16:
2653 {
2654 GLushort *d = ((GLushort *) dst);
2655 const GLfloat scale = (GLfloat) 0xffff;
2656 GLuint i;
2657 for (i = 0; i < n; i++) {
2658 d[i] = (GLushort) (src[i] * scale);
2659 }
2660 }
2661 break;
2662 case MESA_FORMAT_Z_UNORM32:
2663 {
2664 GLuint *d = ((GLuint *) dst);
2665 const GLdouble scale = (GLdouble) 0xffffffff;
2666 GLuint i;
2667 for (i = 0; i < n; i++) {
2668 d[i] = (GLuint) (src[i] * scale);
2669 }
2670 }
2671 break;
2672 case MESA_FORMAT_Z_FLOAT32:
2673 memcpy(dst, src, n * sizeof(GLfloat));
2674 break;
2675 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2676 {
2677 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2678 GLuint i;
2679 for (i = 0; i < n; i++) {
2680 d[i].z = src[i];
2681 }
2682 }
2683 break;
2684 default:
2685 _mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
2686 }
2687 }
2688
2689
2690 /**
2691 * The incoming Z values are always in the range [0, 0xffffffff].
2692 */
2693 void
2694 _mesa_pack_uint_z_row(mesa_format format, GLuint n,
2695 const GLuint *src, void *dst)
2696 {
2697 switch (format) {
2698 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2699 case MESA_FORMAT_X8Z24_UNORM:
2700 {
2701 /* don't disturb the stencil values */
2702 GLuint *d = ((GLuint *) dst);
2703 GLuint i;
2704 for (i = 0; i < n; i++) {
2705 GLuint s = d[i] & 0xff;
2706 GLuint z = src[i] & 0xffffff00;
2707 d[i] = z | s;
2708 }
2709 }
2710 break;
2711 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2712 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2713 {
2714 /* don't disturb the stencil values */
2715 GLuint *d = ((GLuint *) dst);
2716 GLuint i;
2717 for (i = 0; i < n; i++) {
2718 GLuint s = d[i] & 0xff000000;
2719 GLuint z = src[i] >> 8;
2720 d[i] = s | z;
2721 }
2722 }
2723 break;
2724 case MESA_FORMAT_Z_UNORM16:
2725 {
2726 GLushort *d = ((GLushort *) dst);
2727 GLuint i;
2728 for (i = 0; i < n; i++) {
2729 d[i] = src[i] >> 16;
2730 }
2731 }
2732 break;
2733 case MESA_FORMAT_Z_UNORM32:
2734 memcpy(dst, src, n * sizeof(GLfloat));
2735 break;
2736 case MESA_FORMAT_Z_FLOAT32:
2737 {
2738 GLuint *d = ((GLuint *) dst);
2739 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2740 GLuint i;
2741 for (i = 0; i < n; i++) {
2742 d[i] = (GLuint) (src[i] * scale);
2743 assert(d[i] >= 0.0f);
2744 assert(d[i] <= 1.0f);
2745 }
2746 }
2747 break;
2748 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2749 {
2750 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2751 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2752 GLuint i;
2753 for (i = 0; i < n; i++) {
2754 d[i].z = (GLfloat) (src[i] * scale);
2755 assert(d[i].z >= 0.0f);
2756 assert(d[i].z <= 1.0f);
2757 }
2758 }
2759 break;
2760 default:
2761 _mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
2762 }
2763 }
2764
2765
2766 void
2767 _mesa_pack_ubyte_stencil_row(mesa_format format, GLuint n,
2768 const GLubyte *src, void *dst)
2769 {
2770 switch (format) {
2771 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2772 {
2773 /* don't disturb the Z values */
2774 GLuint *d = ((GLuint *) dst);
2775 GLuint i;
2776 for (i = 0; i < n; i++) {
2777 GLuint s = src[i];
2778 GLuint z = d[i] & 0xffffff00;
2779 d[i] = z | s;
2780 }
2781 }
2782 break;
2783 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2784 {
2785 /* don't disturb the Z values */
2786 GLuint *d = ((GLuint *) dst);
2787 GLuint i;
2788 for (i = 0; i < n; i++) {
2789 GLuint s = src[i] << 24;
2790 GLuint z = d[i] & 0xffffff;
2791 d[i] = s | z;
2792 }
2793 }
2794 break;
2795 case MESA_FORMAT_S_UINT8:
2796 memcpy(dst, src, n * sizeof(GLubyte));
2797 break;
2798 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2799 {
2800 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2801 GLuint i;
2802 for (i = 0; i < n; i++) {
2803 d[i].x24s8 = src[i];
2804 }
2805 }
2806 break;
2807 default:
2808 _mesa_problem(NULL, "unexpected format in _mesa_pack_ubyte_stencil_row()");
2809 }
2810 }
2811
2812
2813 /**
2814 * Incoming Z/stencil values are always in uint_24_8 format.
2815 */
2816 void
2817 _mesa_pack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
2818 const GLuint *src, void *dst)
2819 {
2820 switch (format) {
2821 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2822 memcpy(dst, src, n * sizeof(GLuint));
2823 break;
2824 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2825 {
2826 GLuint *d = ((GLuint *) dst);
2827 GLuint i;
2828 for (i = 0; i < n; i++) {
2829 GLuint s = src[i] << 24;
2830 GLuint z = src[i] >> 8;
2831 d[i] = s | z;
2832 }
2833 }
2834 break;
2835 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2836 {
2837 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
2838 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2839 GLuint i;
2840 for (i = 0; i < n; i++) {
2841 GLfloat z = (GLfloat) ((src[i] >> 8) * scale);
2842 d[i].z = z;
2843 d[i].x24s8 = src[i];
2844 }
2845 }
2846 break;
2847 default:
2848 _mesa_problem(NULL, "bad format %s in _mesa_pack_ubyte_s_row",
2849 _mesa_get_format_name(format));
2850 return;
2851 }
2852 }
2853
2854
2855
2856 /**
2857 * Convert a boolean color mask to a packed color where each channel of
2858 * the packed value at dst will be 0 or ~0 depending on the colorMask.
2859 */
2860 void
2861 _mesa_pack_colormask(mesa_format format, const GLubyte colorMask[4], void *dst)
2862 {
2863 GLfloat maskColor[4];
2864
2865 switch (_mesa_get_format_datatype(format)) {
2866 case GL_UNSIGNED_NORMALIZED:
2867 /* simple: 1.0 will convert to ~0 in the right bit positions */
2868 maskColor[0] = colorMask[0] ? 1.0f : 0.0f;
2869 maskColor[1] = colorMask[1] ? 1.0f : 0.0f;
2870 maskColor[2] = colorMask[2] ? 1.0f : 0.0f;
2871 maskColor[3] = colorMask[3] ? 1.0f : 0.0f;
2872 _mesa_pack_float_rgba_row(format, 1,
2873 (const GLfloat (*)[4]) maskColor, dst);
2874 break;
2875 case GL_SIGNED_NORMALIZED:
2876 case GL_FLOAT:
2877 /* These formats are harder because it's hard to know the floating
2878 * point values that will convert to ~0 for each color channel's bits.
2879 * This solution just generates a non-zero value for each color channel
2880 * then fixes up the non-zero values to be ~0.
2881 * Note: we'll need to add special case code if we ever have to deal
2882 * with formats with unequal color channel sizes, like R11_G11_B10.
2883 * We issue a warning below for channel sizes other than 8,16,32.
2884 */
2885 {
2886 GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
2887 GLuint bytes = _mesa_get_format_bytes(format);
2888 GLuint i;
2889
2890 /* this should put non-zero values into the channels of dst */
2891 maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
2892 maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
2893 maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
2894 maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
2895 _mesa_pack_float_rgba_row(format, 1,
2896 (const GLfloat (*)[4]) maskColor, dst);
2897
2898 /* fix-up the dst channels by converting non-zero values to ~0 */
2899 if (bits == 8) {
2900 GLubyte *d = (GLubyte *) dst;
2901 for (i = 0; i < bytes; i++) {
2902 d[i] = d[i] ? 0xff : 0x0;
2903 }
2904 }
2905 else if (bits == 16) {
2906 GLushort *d = (GLushort *) dst;
2907 for (i = 0; i < bytes / 2; i++) {
2908 d[i] = d[i] ? 0xffff : 0x0;
2909 }
2910 }
2911 else if (bits == 32) {
2912 GLuint *d = (GLuint *) dst;
2913 for (i = 0; i < bytes / 4; i++) {
2914 d[i] = d[i] ? 0xffffffffU : 0x0;
2915 }
2916 }
2917 else {
2918 _mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
2919 return;
2920 }
2921 }
2922 break;
2923 default:
2924 _mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
2925 return;
2926 }
2927 }