projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: rename MESA_FORMAT_X8Z24_UNORM -> MESA_FORMAT_X8_UINT_Z24_UNORM
[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[GCOMP]);
1048 d[0] = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
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[GCOMP]);
1094 GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
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_R8G8B8A8_SRGB */
1112
1113 static void
1114 pack_ubyte_SABGR8(const GLubyte src[4], void *dst)
1115 {
1116 GLuint *d = ((GLuint *) dst);
1117 GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1118 GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1119 GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1120 *d = PACK_COLOR_8888(src[ACOMP], b, g, r);
1121 }
1122
1123 static void
1124 pack_float_SABGR8(const GLfloat src[4], void *dst)
1125 {
1126 GLuint *d = ((GLuint *) dst);
1127 GLubyte r, g, b, a;
1128 r = linear_float_to_srgb_ubyte(src[RCOMP]);
1129 g = linear_float_to_srgb_ubyte(src[GCOMP]);
1130 b = linear_float_to_srgb_ubyte(src[BCOMP]);
1131 UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1132 *d = PACK_COLOR_8888(a, b, g, r);
1133 }
1134
1135
1136 /* MESA_FORMAT_L_SRGB8 */
1137
1138 static void
1139 pack_ubyte_SL8(const GLubyte src[4], void *dst)
1140 {
1141 GLubyte *d = ((GLubyte *) dst);
1142 *d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1143 }
1144
1145 static void
1146 pack_float_SL8(const GLfloat src[4], void *dst)
1147 {
1148 GLubyte *d = ((GLubyte *) dst);
1149 GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
1150 *d = l;
1151 }
1152
1153
1154 /* MESA_FORMAT_L8A8_SRGB */
1155
1156 static void
1157 pack_ubyte_SLA8(const GLubyte src[4], void *dst)
1158 {
1159 GLushort *d = ((GLushort *) dst);
1160 GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1161 *d = PACK_COLOR_88(src[ACOMP], l);
1162 }
1163
1164 static void
1165 pack_float_SLA8(const GLfloat src[4], void *dst)
1166 {
1167 GLushort *d = ((GLushort *) dst);
1168 GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
1169 CLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1170 *d = PACK_COLOR_88(a, l);
1171 }
1172
1173
1174 /* MESA_FORMAT_RGBA_FLOAT32 */
1175
1176 static void
1177 pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
1178 {
1179 GLfloat *d = ((GLfloat *) dst);
1180 d[0] = UBYTE_TO_FLOAT(src[0]);
1181 d[1] = UBYTE_TO_FLOAT(src[1]);
1182 d[2] = UBYTE_TO_FLOAT(src[2]);
1183 d[3] = UBYTE_TO_FLOAT(src[3]);
1184 }
1185
1186 static void
1187 pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
1188 {
1189 GLfloat *d = ((GLfloat *) dst);
1190 d[0] = src[0];
1191 d[1] = src[1];
1192 d[2] = src[2];
1193 d[3] = src[3];
1194 }
1195
1196
1197 /* MESA_FORMAT_RGBA_FLOAT16 */
1198
1199 static void
1200 pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
1201 {
1202 GLhalfARB *d = ((GLhalfARB *) dst);
1203 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1204 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1205 d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1206 d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
1207 }
1208
1209 static void
1210 pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
1211 {
1212 GLhalfARB *d = ((GLhalfARB *) dst);
1213 d[0] = _mesa_float_to_half(src[0]);
1214 d[1] = _mesa_float_to_half(src[1]);
1215 d[2] = _mesa_float_to_half(src[2]);
1216 d[3] = _mesa_float_to_half(src[3]);
1217 }
1218
1219
1220 /* MESA_FORMAT_RGB_FLOAT32 */
1221
1222 static void
1223 pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
1224 {
1225 GLfloat *d = ((GLfloat *) dst);
1226 d[0] = UBYTE_TO_FLOAT(src[0]);
1227 d[1] = UBYTE_TO_FLOAT(src[1]);
1228 d[2] = UBYTE_TO_FLOAT(src[2]);
1229 }
1230
1231 static void
1232 pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
1233 {
1234 GLfloat *d = ((GLfloat *) dst);
1235 d[0] = src[0];
1236 d[1] = src[1];
1237 d[2] = src[2];
1238 }
1239
1240
1241 /* MESA_FORMAT_RGB_FLOAT16 */
1242
1243 static void
1244 pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
1245 {
1246 GLhalfARB *d = ((GLhalfARB *) dst);
1247 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1248 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1249 d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1250 }
1251
1252 static void
1253 pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
1254 {
1255 GLhalfARB *d = ((GLhalfARB *) dst);
1256 d[0] = _mesa_float_to_half(src[0]);
1257 d[1] = _mesa_float_to_half(src[1]);
1258 d[2] = _mesa_float_to_half(src[2]);
1259 }
1260
1261
1262 /* MESA_FORMAT_A_FLOAT32 */
1263
1264 static void
1265 pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
1266 {
1267 GLfloat *d = ((GLfloat *) dst);
1268 d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
1269 }
1270
1271 static void
1272 pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
1273 {
1274 GLfloat *d = ((GLfloat *) dst);
1275 d[0] = src[ACOMP];
1276 }
1277
1278
1279 /* MESA_FORMAT_A_FLOAT16 */
1280
1281 static void
1282 pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
1283 {
1284 GLhalfARB *d = ((GLhalfARB *) dst);
1285 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1286 }
1287
1288 static void
1289 pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1290 {
1291 GLhalfARB *d = ((GLhalfARB *) dst);
1292 d[0] = _mesa_float_to_half(src[ACOMP]);
1293 }
1294
1295
1296 /* MESA_FORMAT_L_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
1297
1298 static void
1299 pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
1300 {
1301 GLfloat *d = ((GLfloat *) dst);
1302 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1303 }
1304
1305 static void
1306 pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
1307 {
1308 GLfloat *d = ((GLfloat *) dst);
1309 d[0] = src[RCOMP];
1310 }
1311
1312
1313 /* MESA_FORMAT_L_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
1314
1315 static void
1316 pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
1317 {
1318 GLhalfARB *d = ((GLhalfARB *) dst);
1319 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1320 }
1321
1322 static void
1323 pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
1324 {
1325 GLhalfARB *d = ((GLhalfARB *) dst);
1326 d[0] = _mesa_float_to_half(src[RCOMP]);
1327 }
1328
1329
1330 /* MESA_FORMAT_LA_FLOAT32 */
1331
1332 static void
1333 pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
1334 {
1335 GLfloat *d = ((GLfloat *) dst);
1336 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1337 d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
1338 }
1339
1340 static void
1341 pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
1342 {
1343 GLfloat *d = ((GLfloat *) dst);
1344 d[0] = src[RCOMP];
1345 d[1] = src[ACOMP];
1346 }
1347
1348
1349 /* MESA_FORMAT_LA_FLOAT16 */
1350
1351 static void
1352 pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
1353 {
1354 GLhalfARB *d = ((GLhalfARB *) dst);
1355 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1356 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1357 }
1358
1359 static void
1360 pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
1361 {
1362 GLhalfARB *d = ((GLhalfARB *) dst);
1363 d[0] = _mesa_float_to_half(src[RCOMP]);
1364 d[1] = _mesa_float_to_half(src[ACOMP]);
1365 }
1366
1367
1368 /* MESA_FORMAT_RG_FLOAT32 */
1369
1370 static void
1371 pack_ubyte_RG_FLOAT32(const GLubyte src[4], void *dst)
1372 {
1373 GLfloat *d = ((GLfloat *) dst);
1374 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1375 d[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1376 }
1377
1378 static void
1379 pack_float_RG_FLOAT32(const GLfloat src[4], void *dst)
1380 {
1381 GLfloat *d = ((GLfloat *) dst);
1382 d[0] = src[RCOMP];
1383 d[1] = src[GCOMP];
1384 }
1385
1386
1387 /* MESA_FORMAT_RG_FLOAT16 */
1388
1389 static void
1390 pack_ubyte_RG_FLOAT16(const GLubyte src[4], void *dst)
1391 {
1392 GLhalfARB *d = ((GLhalfARB *) dst);
1393 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1394 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[GCOMP]));
1395 }
1396
1397 static void
1398 pack_float_RG_FLOAT16(const GLfloat src[4], void *dst)
1399 {
1400 GLhalfARB *d = ((GLhalfARB *) dst);
1401 d[0] = _mesa_float_to_half(src[RCOMP]);
1402 d[1] = _mesa_float_to_half(src[GCOMP]);
1403 }
1404
1405
1406 /* MESA_FORMAT_DUDV8 */
1407
1408 static void
1409 pack_ubyte_DUDV8(const GLubyte src[4], void *dst)
1410 {
1411 /* XXX is this ever used? */
1412 GLushort *d = ((GLushort *) dst);
1413 *d = PACK_COLOR_88(src[0], src[1]);
1414 }
1415
1416 static void
1417 pack_float_DUDV8(const GLfloat src[4], void *dst)
1418 {
1419 GLushort *d = ((GLushort *) dst);
1420 GLbyte du, dv;
1421 du = FLOAT_TO_BYTE(CLAMP(src[0], 0.0F, 1.0F));
1422 dv = FLOAT_TO_BYTE(CLAMP(src[1], 0.0F, 1.0F));
1423 *d = PACK_COLOR_88(du, dv);
1424 }
1425
1426
1427 /* MESA_FORMAT_RGBA_UNORM16 */
1428
1429 static void
1430 pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
1431 {
1432 GLushort *d = ((GLushort *) dst);
1433 d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1434 d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1435 d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1436 d[3] = UBYTE_TO_USHORT(src[ACOMP]);
1437 }
1438
1439 static void
1440 pack_float_RGBA_16(const GLfloat src[4], void *dst)
1441 {
1442 GLushort *d = ((GLushort *) dst);
1443 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1444 UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1445 UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1446 UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
1447 }
1448
1449
1450
1451 /*
1452 * MESA_FORMAT_R_SNORM8
1453 */
1454
1455 static void
1456 pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
1457 {
1458 GLbyte *d = (GLbyte *) dst;
1459 *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1460 }
1461
1462
1463 /*
1464 * MESA_FORMAT_R8G8_SNORM
1465 */
1466
1467 static void
1468 pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
1469 {
1470 GLushort *d = (GLushort *) dst;
1471 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1472 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1473 *d = (g << 8) | r;
1474 }
1475
1476
1477 /*
1478 * MESA_FORMAT_X8B8G8R8_SNORM
1479 */
1480
1481 static void
1482 pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
1483 {
1484 GLuint *d = (GLuint *) dst;
1485 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1486 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1487 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1488 GLbyte a = 127;
1489 *d = PACK_COLOR_8888(r, g, b, a);
1490 }
1491
1492
1493 /*
1494 * MESA_FORMAT_A8B8G8R8_SNORM
1495 */
1496
1497 static void
1498 pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
1499 {
1500 GLuint *d = (GLuint *) dst;
1501 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1502 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1503 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1504 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1505 *d = PACK_COLOR_8888(r, g, b, a);
1506 }
1507
1508
1509 /*
1510 * MESA_FORMAT_R8G8B8A8_SNORM
1511 */
1512
1513 static void
1514 pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
1515 {
1516 GLuint *d = (GLuint *) dst;
1517 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1518 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1519 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1520 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1521 *d = PACK_COLOR_8888(a, b, g, r);
1522 }
1523
1524
1525 /*
1526 * MESA_FORMAT_R_SNORM16
1527 */
1528
1529 static void
1530 pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
1531 {
1532 GLshort *d = (GLshort *) dst;
1533 *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1534 }
1535
1536
1537 /*
1538 * MESA_FORMAT_R16G16_SNORM
1539 */
1540
1541 static void
1542 pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
1543 {
1544 GLuint *d = (GLuint *) dst;
1545 GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1546 GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1547 *d = (g << 16) | (r & 0xffff);
1548 }
1549
1550
1551 /*
1552 * MESA_FORMAT_RGB_SNORM16
1553 */
1554
1555 static void
1556 pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
1557 {
1558 GLshort *d = (GLshort *) dst;
1559 d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1560 d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1561 d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1562 }
1563
1564
1565 /*
1566 * MESA_FORMAT_RGBA_SNORM16
1567 */
1568
1569 static void
1570 pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
1571 {
1572 GLshort *d = (GLshort *) dst;
1573 d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1574 d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1575 d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1576 d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1577 }
1578
1579
1580 /*
1581 * MESA_FORMAT_A_SNORM8
1582 */
1583
1584 static void
1585 pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
1586 {
1587 GLbyte *d = (GLbyte *) dst;
1588 *d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1589 }
1590
1591
1592 /*
1593 * MESA_FORMAT_L_SNORM8
1594 */
1595
1596 static void
1597 pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
1598 {
1599 GLbyte *d = (GLbyte *) dst;
1600 *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1601 }
1602
1603
1604 /*
1605 * MESA_FORMAT_L8A8_SNORM
1606 */
1607
1608 static void
1609 pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
1610 {
1611 GLushort *d = (GLushort *) dst;
1612 GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1613 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1614 *d = (a << 8) | l;
1615 }
1616
1617
1618 /*
1619 * MESA_FORMAT_A_SNORM16
1620 */
1621
1622 static void
1623 pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
1624 {
1625 GLshort *d = (GLshort *) dst;
1626 *d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1627 }
1628
1629
1630 /*
1631 * MESA_FORMAT_L_SNORM16
1632 */
1633
1634 static void
1635 pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
1636 {
1637 GLshort *d = (GLshort *) dst;
1638 *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1639 }
1640
1641
1642 /*
1643 * MESA_FORMAT_LA_SNORM16
1644 */
1645
1646 static void
1647 pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
1648 {
1649 GLuint *d = (GLuint *) dst;
1650 GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1651 GLshort a = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1652 *d = PACK_COLOR_1616(a, l);
1653 }
1654
1655
1656 /*
1657 * MESA_FORMAT_R9G9B9E5_FLOAT;
1658 */
1659
1660 static void
1661 pack_float_RGB9_E5_FLOAT(const GLfloat src[4], void *dst)
1662 {
1663 GLuint *d = (GLuint *) dst;
1664 *d = float3_to_rgb9e5(src);
1665 }
1666
1667 static void
1668 pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
1669 {
1670 GLuint *d = (GLuint *) dst;
1671 GLfloat rgb[3];
1672 rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1673 rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1674 rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1675 *d = float3_to_rgb9e5(rgb);
1676 }
1677
1678
1679
1680 /*
1681 * MESA_FORMAT_R11G11B10_FLOAT;
1682 */
1683
1684 static void
1685 pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
1686 {
1687 GLuint *d = (GLuint *) dst;
1688 GLfloat rgb[3];
1689 rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1690 rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1691 rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1692 *d = float3_to_r11g11b10f(rgb);
1693 }
1694
1695 static void
1696 pack_float_R11_G11_B10_FLOAT(const GLfloat src[4], void *dst)
1697 {
1698 GLuint *d = (GLuint *) dst;
1699 *d = float3_to_r11g11b10f(src);
1700 }
1701
1702
1703 /*
1704 * MESA_FORMAT_B4G4R4X4_UNORM
1705 */
1706
1707 static void
1708 pack_ubyte_XRGB4444_UNORM(const GLubyte src[4], void *dst)
1709 {
1710 GLushort *d = ((GLushort *) dst);
1711 *d = PACK_COLOR_4444(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1712 }
1713
1714 static void
1715 pack_float_XRGB4444_UNORM(const GLfloat src[4], void *dst)
1716 {
1717 GLubyte v[4];
1718 _mesa_unclamped_float_rgba_to_ubyte(v, src);
1719 pack_ubyte_XRGB4444_UNORM(v, dst);
1720 }
1721
1722
1723 /*
1724 * MESA_FORMAT_B5G5R5X1_UNORM
1725 */
1726
1727 static void
1728 pack_ubyte_XRGB1555_UNORM(const GLubyte src[4], void *dst)
1729 {
1730 GLushort *d = ((GLushort *) dst);
1731 *d = PACK_COLOR_1555(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1732 }
1733
1734 static void
1735 pack_float_XRGB1555_UNORM(const GLfloat src[4], void *dst)
1736 {
1737 GLubyte v[4];
1738 _mesa_unclamped_float_rgba_to_ubyte(v, src);
1739 pack_ubyte_XRGB1555_UNORM(v, dst);
1740 }
1741
1742
1743 /*
1744 * MESA_FORMAT_R8G8B8X8_SNORM
1745 */
1746
1747 static void
1748 pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
1749 {
1750 GLuint *d = (GLuint *) dst;
1751 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1752 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1753 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1754 *d = PACK_COLOR_8888(127, b, g, r);
1755 }
1756
1757
1758 /*
1759 * MESA_FORMAT_R8G8B8X8_SRGB
1760 */
1761
1762 static void
1763 pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
1764 {
1765 GLuint *d = (GLuint *) dst;
1766 GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1767 GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1768 GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1769 *d = PACK_COLOR_8888(127, b, g, r);
1770 }
1771
1772
1773 /* MESA_FORMAT_B10G10R10X2_UNORM */
1774
1775 static void
1776 pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
1777 {
1778 GLuint *d = ((GLuint *) dst);
1779 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1780 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1781 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1782 *d = PACK_COLOR_2101010_US(3, r, g, b);
1783 }
1784
1785 static void
1786 pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
1787 {
1788 GLuint *d = ((GLuint *) dst);
1789 GLushort r, g, b;
1790 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1791 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1792 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1793 *d = PACK_COLOR_2101010_US(3, r, g, b);
1794 }
1795
1796
1797 /* MESA_FORMAT_RGBX_UNORM16 */
1798
1799 static void
1800 pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
1801 {
1802 GLushort *d = ((GLushort *) dst);
1803 d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1804 d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1805 d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1806 d[3] = 65535;
1807 }
1808
1809 static void
1810 pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
1811 {
1812 GLushort *d = ((GLushort *) dst);
1813 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1814 UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1815 UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1816 d[3] = 65535;
1817 }
1818
1819
1820 /* MESA_FORMAT_RGBX_SNORM16 */
1821
1822 static void
1823 pack_float_XBGR16161616_SNORM(const GLfloat src[4], void *dst)
1824 {
1825 GLushort *d = ((GLushort *) dst);
1826 UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
1827 UNCLAMPED_FLOAT_TO_SHORT(d[1], src[GCOMP]);
1828 UNCLAMPED_FLOAT_TO_SHORT(d[2], src[BCOMP]);
1829 d[3] = 32767;
1830 }
1831
1832
1833 /* MESA_FORMAT_RGBX_FLOAT16 */
1834
1835 static void
1836 pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
1837 {
1838 GLushort *d = ((GLushort *) dst);
1839 d[0] = _mesa_float_to_half(src[RCOMP]);
1840 d[1] = _mesa_float_to_half(src[GCOMP]);
1841 d[2] = _mesa_float_to_half(src[BCOMP]);
1842 d[3] = _mesa_float_to_half(1.0);
1843 }
1844
1845 /* MESA_FORMAT_RGBX_FLOAT32 */
1846
1847 static void
1848 pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
1849 {
1850 GLfloat *d = ((GLfloat *) dst);
1851 d[0] = src[RCOMP];
1852 d[1] = src[GCOMP];
1853 d[2] = src[BCOMP];
1854 d[3] = 1.0;
1855 }
1856
1857 /* MESA_FORMAT_R10G10B10A2_UNORM */
1858
1859 static void
1860 pack_ubyte_ABGR2101010(const GLubyte src[4], void *dst)
1861 {
1862 GLuint *d = ((GLuint *) dst);
1863 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1864 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1865 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1866 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1867 *d = PACK_COLOR_2101010_US(a, b, g, r);
1868 }
1869
1870 static void
1871 pack_float_ABGR2101010(const GLfloat src[4], void *dst)
1872 {
1873 GLuint *d = ((GLuint *) dst);
1874 GLushort r, g, b, a;
1875 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1876 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1877 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1878 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1879 *d = PACK_COLOR_2101010_US(a, b, g, r);
1880 }
1881
1882 /*
1883 * MESA_FORMAT_G8R8_SNORM
1884 */
1885
1886 static void
1887 pack_float_SIGNED_RG88(const GLfloat src[4], void *dst)
1888 {
1889 GLushort *d = (GLushort *) dst;
1890 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1891 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1892 *d = (r << 8) | (g & 0xff);
1893 }
1894
1895 /*
1896 * MESA_FORMAT_G16R16_SNORM
1897 */
1898
1899 static void
1900 pack_float_SIGNED_RG1616(const GLfloat src[4], void *dst)
1901 {
1902 GLuint *d = (GLuint *) dst;
1903 GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1904 GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1905 *d = (r << 16) | (g & 0xffff);
1906 }
1907
1908 /*
1909 * MESA_FORMAT_B8G8R8X8_SRGB
1910 */
1911
1912 static void
1913 pack_float_XRGB8888_SRGB(const GLfloat src[4], void *dst)
1914 {
1915 GLuint *d = (GLuint *) dst;
1916 GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1917 GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1918 GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1919 *d = PACK_COLOR_8888(127, r, g, b);
1920 }
1921
1922 /**
1923 * Return a function that can pack a GLubyte rgba[4] color.
1924 */
1925 gl_pack_ubyte_rgba_func
1926 _mesa_get_pack_ubyte_rgba_function(mesa_format format)
1927 {
1928 static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
1929 static GLboolean initialized = GL_FALSE;
1930
1931 if (!initialized) {
1932 memset(table, 0, sizeof(table));
1933
1934 table[MESA_FORMAT_NONE] = NULL;
1935
1936 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_ubyte_RGBA8888;
1937 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_ubyte_RGBA8888_REV;
1938 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_ubyte_ARGB8888;
1939 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_ubyte_ARGB8888_REV;
1940 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_ubyte_RGBA8888; /* reused */
1941 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_ubyte_RGBA8888_REV; /* reused */
1942 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_ubyte_XRGB8888;
1943 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_ubyte_XRGB8888_REV;
1944 table[MESA_FORMAT_BGR_UNORM8] = pack_ubyte_RGB888;
1945 table[MESA_FORMAT_RGB_UNORM8] = pack_ubyte_BGR888;
1946 table[MESA_FORMAT_B5G6R5_UNORM] = pack_ubyte_RGB565;
1947 table[MESA_FORMAT_R5G6B5_UNORM] = pack_ubyte_RGB565_REV;
1948 table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_ubyte_ARGB4444;
1949 table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_ubyte_ARGB4444_REV;
1950 table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_ubyte_RGBA5551;
1951 table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_ubyte_ARGB1555;
1952 table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_ubyte_ARGB1555_REV;
1953 table[MESA_FORMAT_L4A4_UNORM] = pack_ubyte_AL44;
1954 table[MESA_FORMAT_L8A8_UNORM] = pack_ubyte_AL88;
1955 table[MESA_FORMAT_A8L8_UNORM] = pack_ubyte_AL88_REV;
1956 table[MESA_FORMAT_L16A16_UNORM] = pack_ubyte_AL1616;
1957 table[MESA_FORMAT_A16L16_UNORM] = pack_ubyte_AL1616_REV;
1958 table[MESA_FORMAT_B2G3R3_UNORM] = pack_ubyte_RGB332;
1959 table[MESA_FORMAT_A_UNORM8] = pack_ubyte_A8;
1960 table[MESA_FORMAT_A_UNORM16] = pack_ubyte_A16;
1961 table[MESA_FORMAT_L_UNORM8] = pack_ubyte_L8;
1962 table[MESA_FORMAT_L_UNORM16] = pack_ubyte_L16;
1963 table[MESA_FORMAT_I_UNORM8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
1964 table[MESA_FORMAT_I_UNORM16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
1965 table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
1966 table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
1967 table[MESA_FORMAT_R_UNORM8] = pack_ubyte_R8;
1968 table[MESA_FORMAT_R8G8_UNORM] = pack_ubyte_GR88;
1969 table[MESA_FORMAT_G8R8_UNORM] = pack_ubyte_RG88;
1970 table[MESA_FORMAT_R_UNORM16] = pack_ubyte_R16;
1971 table[MESA_FORMAT_R16G16_UNORM] = pack_ubyte_GR1616;
1972 table[MESA_FORMAT_G16R16_UNORM] = pack_ubyte_RG1616;
1973 table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_ubyte_ARGB2101010;
1974 table[MESA_FORMAT_R10G10B10A2_UINT] = pack_ubyte_ABGR2101010_UINT;
1975
1976 /* should never convert RGBA to these formats */
1977 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
1978 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
1979 table[MESA_FORMAT_Z_UNORM16] = NULL;
1980 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
1981 table[MESA_FORMAT_X8_UINT_Z24_UNORM] = NULL;
1982 table[MESA_FORMAT_Z_UNORM32] = NULL;
1983 table[MESA_FORMAT_S_UINT8] = NULL;
1984
1985 /* sRGB */
1986 table[MESA_FORMAT_BGR_SRGB8] = pack_ubyte_SRGB8;
1987 table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_ubyte_SRGBA8;
1988 table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_ubyte_SARGB8;
1989 table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_ubyte_SABGR8;
1990 table[MESA_FORMAT_L_SRGB8] = pack_ubyte_SL8;
1991 table[MESA_FORMAT_L8A8_SRGB] = pack_ubyte_SLA8;
1992 /* n/a */
1993 table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
1994 table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
1995 table[MESA_FORMAT_SRGBA_DXT3] = NULL; /* pack_ubyte_SRGBA_DXT3; */
1996 table[MESA_FORMAT_SRGBA_DXT5] = NULL; /* pack_ubyte_SRGBA_DXT5; */
1997
1998 table[MESA_FORMAT_RGB_FXT1] = NULL; /* pack_ubyte_RGB_FXT1; */
1999 table[MESA_FORMAT_RGBA_FXT1] = NULL; /* pack_ubyte_RGBA_FXT1; */
2000 table[MESA_FORMAT_RGB_DXT1] = NULL; /* pack_ubyte_RGB_DXT1; */
2001 table[MESA_FORMAT_RGBA_DXT1] = NULL; /* pack_ubyte_RGBA_DXT1; */
2002 table[MESA_FORMAT_RGBA_DXT3] = NULL; /* pack_ubyte_RGBA_DXT3; */
2003 table[MESA_FORMAT_RGBA_DXT5] = NULL; /* pack_ubyte_RGBA_DXT5; */
2004
2005 table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
2006 table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
2007 table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
2008 table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
2009 table[MESA_FORMAT_A_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
2010 table[MESA_FORMAT_A_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
2011 table[MESA_FORMAT_L_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
2012 table[MESA_FORMAT_L_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
2013 table[MESA_FORMAT_LA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
2014 table[MESA_FORMAT_LA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
2015 table[MESA_FORMAT_I_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
2016 table[MESA_FORMAT_I_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
2017 table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
2018 table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
2019 table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
2020 table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
2021
2022 /* n/a */
2023 table[MESA_FORMAT_RGBA_SINT8] = NULL; /* pack_ubyte_RGBA_INT8 */
2024 table[MESA_FORMAT_RGBA_SINT16] = NULL; /* pack_ubyte_RGBA_INT16 */
2025 table[MESA_FORMAT_RGBA_SINT32] = NULL; /* pack_ubyte_RGBA_INT32 */
2026 table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
2027 table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
2028 table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
2029
2030 table[MESA_FORMAT_DUDV8] = pack_ubyte_DUDV8;
2031
2032 table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2033
2034 /* n/a */
2035 table[MESA_FORMAT_R_SNORM8] = NULL;
2036 table[MESA_FORMAT_R8G8_SNORM] = NULL;
2037 table[MESA_FORMAT_X8B8G8R8_SNORM] = NULL;
2038 table[MESA_FORMAT_A8B8G8R8_SNORM] = NULL;
2039 table[MESA_FORMAT_R8G8B8A8_SNORM] = NULL;
2040 table[MESA_FORMAT_R_SNORM16] = NULL;
2041 table[MESA_FORMAT_R16G16_SNORM] = NULL;
2042 table[MESA_FORMAT_RGB_SNORM16] = NULL;
2043 table[MESA_FORMAT_RGBA_SNORM16] = NULL;
2044 table[MESA_FORMAT_A_SNORM8] = NULL;
2045 table[MESA_FORMAT_L_SNORM8] = NULL;
2046 table[MESA_FORMAT_L8A8_SNORM] = NULL;
2047 table[MESA_FORMAT_I_SNORM8] = NULL;
2048 table[MESA_FORMAT_A_SNORM16] = NULL;
2049 table[MESA_FORMAT_L_SNORM16] = NULL;
2050 table[MESA_FORMAT_LA_SNORM16] = NULL;
2051 table[MESA_FORMAT_I_SNORM16] = NULL;
2052
2053
2054 table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2055
2056 table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_ubyte_RGB9_E5_FLOAT;
2057 table[MESA_FORMAT_R11G11B10_FLOAT] = pack_ubyte_R11_G11_B10_FLOAT;
2058
2059 table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_ubyte_XRGB4444_UNORM;
2060 table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_ubyte_XRGB1555_UNORM;
2061 table[MESA_FORMAT_R8G8B8X8_SNORM] = NULL;
2062 table[MESA_FORMAT_R8G8B8X8_SRGB] = NULL;
2063 table[MESA_FORMAT_RGBX_UINT8] = NULL;
2064 table[MESA_FORMAT_RGBX_SINT8] = NULL;
2065 table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_ubyte_XRGB2101010_UNORM;
2066 table[MESA_FORMAT_RGBX_UNORM16] = pack_ubyte_XBGR16161616_UNORM;
2067 table[MESA_FORMAT_RGBX_SNORM16] = NULL;
2068 table[MESA_FORMAT_RGBX_FLOAT16] = NULL;
2069 table[MESA_FORMAT_RGBX_UINT16] = NULL;
2070 table[MESA_FORMAT_RGBX_SINT16] = NULL;
2071 table[MESA_FORMAT_RGBX_FLOAT32] = NULL;
2072 table[MESA_FORMAT_RGBX_UINT32] = NULL;
2073 table[MESA_FORMAT_RGBX_SINT32] = NULL;
2074
2075 table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_ubyte_ABGR2101010;
2076
2077 table[MESA_FORMAT_B8G8R8X8_SRGB] = NULL;
2078
2079 initialized = GL_TRUE;
2080 }
2081
2082 return table[format];
2083 }
2084
2085
2086
2087 /**
2088 * Return a function that can pack a GLfloat rgba[4] color.
2089 */
2090 gl_pack_float_rgba_func
2091 _mesa_get_pack_float_rgba_function(mesa_format format)
2092 {
2093 static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
2094 static GLboolean initialized = GL_FALSE;
2095
2096 if (!initialized) {
2097 memset(table, 0, sizeof(table));
2098
2099 table[MESA_FORMAT_NONE] = NULL;
2100
2101 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_float_RGBA8888;
2102 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_float_RGBA8888_REV;
2103 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_float_ARGB8888;
2104 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_float_ARGB8888_REV;
2105 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_float_RGBA8888; /* reused */
2106 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_float_RGBA8888_REV; /* reused */
2107 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_float_XRGB8888;
2108 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_float_XRGB8888_REV;
2109 table[MESA_FORMAT_BGR_UNORM8] = pack_float_RGB888;
2110 table[MESA_FORMAT_RGB_UNORM8] = pack_float_BGR888;
2111 table[MESA_FORMAT_B5G6R5_UNORM] = pack_float_RGB565;
2112 table[MESA_FORMAT_R5G6B5_UNORM] = pack_float_RGB565_REV;
2113 table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_float_ARGB4444;
2114 table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_float_ARGB4444_REV;
2115 table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_float_RGBA5551;
2116 table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_float_ARGB1555;
2117 table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_float_ARGB1555_REV;
2118
2119 table[MESA_FORMAT_L4A4_UNORM] = pack_float_AL44;
2120 table[MESA_FORMAT_L8A8_UNORM] = pack_float_AL88;
2121 table[MESA_FORMAT_A8L8_UNORM] = pack_float_AL88_REV;
2122 table[MESA_FORMAT_L16A16_UNORM] = pack_float_AL1616;
2123 table[MESA_FORMAT_A16L16_UNORM] = pack_float_AL1616_REV;
2124 table[MESA_FORMAT_B2G3R3_UNORM] = pack_float_RGB332;
2125 table[MESA_FORMAT_A_UNORM8] = pack_float_A8;
2126 table[MESA_FORMAT_A_UNORM16] = pack_float_A16;
2127 table[MESA_FORMAT_L_UNORM8] = pack_float_L8;
2128 table[MESA_FORMAT_L_UNORM16] = pack_float_L16;
2129 table[MESA_FORMAT_I_UNORM8] = pack_float_L8; /* reuse pack_float_L8 */
2130 table[MESA_FORMAT_I_UNORM16] = pack_float_L16; /* reuse pack_float_L16 */
2131 table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
2132 table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
2133 table[MESA_FORMAT_R_UNORM8] = pack_float_R8;
2134 table[MESA_FORMAT_R8G8_UNORM] = pack_float_GR88;
2135 table[MESA_FORMAT_G8R8_UNORM] = pack_float_RG88;
2136 table[MESA_FORMAT_R_UNORM16] = pack_float_R16;
2137 table[MESA_FORMAT_R16G16_UNORM] = pack_float_GR1616;
2138 table[MESA_FORMAT_G16R16_UNORM] = pack_float_RG1616;
2139 table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_float_ARGB2101010;
2140 table[MESA_FORMAT_R10G10B10A2_UINT] = pack_float_ABGR2101010_UINT;
2141
2142 /* should never convert RGBA to these formats */
2143 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
2144 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
2145 table[MESA_FORMAT_Z_UNORM16] = NULL;
2146 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
2147 table[MESA_FORMAT_X8_UINT_Z24_UNORM] = NULL;
2148 table[MESA_FORMAT_Z_UNORM32] = NULL;
2149 table[MESA_FORMAT_S_UINT8] = NULL;
2150
2151 table[MESA_FORMAT_BGR_SRGB8] = pack_float_SRGB8;
2152 table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_float_SRGBA8;
2153 table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_float_SARGB8;
2154 table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_float_SABGR8;
2155 table[MESA_FORMAT_L_SRGB8] = pack_float_SL8;
2156 table[MESA_FORMAT_L8A8_SRGB] = pack_float_SLA8;
2157
2158 /* n/a */
2159 table[MESA_FORMAT_SRGB_DXT1] = NULL;
2160 table[MESA_FORMAT_SRGBA_DXT1] = NULL;
2161 table[MESA_FORMAT_SRGBA_DXT3] = NULL;
2162 table[MESA_FORMAT_SRGBA_DXT5] = NULL;
2163
2164 table[MESA_FORMAT_RGB_FXT1] = NULL;
2165 table[MESA_FORMAT_RGBA_FXT1] = NULL;
2166 table[MESA_FORMAT_RGB_DXT1] = NULL;
2167 table[MESA_FORMAT_RGBA_DXT1] = NULL;
2168 table[MESA_FORMAT_RGBA_DXT3] = NULL;
2169 table[MESA_FORMAT_RGBA_DXT5] = NULL;
2170
2171 table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
2172 table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
2173 table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
2174 table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
2175 table[MESA_FORMAT_A_FLOAT32] = pack_float_ALPHA_FLOAT32;
2176 table[MESA_FORMAT_A_FLOAT16] = pack_float_ALPHA_FLOAT16;
2177 table[MESA_FORMAT_L_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2178 table[MESA_FORMAT_L_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2179 table[MESA_FORMAT_LA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
2180 table[MESA_FORMAT_LA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
2181
2182 table[MESA_FORMAT_I_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2183 table[MESA_FORMAT_I_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2184 table[MESA_FORMAT_R_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
2185 table[MESA_FORMAT_R_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
2186 table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
2187 table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
2188
2189 /* n/a */
2190 table[MESA_FORMAT_RGBA_SINT8] = NULL;
2191 table[MESA_FORMAT_RGBA_SINT16] = NULL;
2192 table[MESA_FORMAT_RGBA_SINT32] = NULL;
2193 table[MESA_FORMAT_RGBA_UINT8] = NULL;
2194 table[MESA_FORMAT_RGBA_UINT16] = NULL;
2195 table[MESA_FORMAT_RGBA_UINT32] = NULL;
2196
2197 table[MESA_FORMAT_DUDV8] = pack_float_DUDV8;
2198
2199 table[MESA_FORMAT_RGBA_UNORM16] = pack_float_RGBA_16;
2200
2201 table[MESA_FORMAT_R_SNORM8] = pack_float_SIGNED_R8;
2202 table[MESA_FORMAT_R8G8_SNORM] = pack_float_SIGNED_RG88_REV;
2203 table[MESA_FORMAT_X8B8G8R8_SNORM] = pack_float_SIGNED_RGBX8888;
2204 table[MESA_FORMAT_A8B8G8R8_SNORM] = pack_float_SIGNED_RGBA8888;
2205 table[MESA_FORMAT_R8G8B8A8_SNORM] = pack_float_SIGNED_RGBA8888_REV;
2206 table[MESA_FORMAT_R_SNORM16] = pack_float_SIGNED_R16;
2207 table[MESA_FORMAT_R16G16_SNORM] = pack_float_SIGNED_GR1616;
2208 table[MESA_FORMAT_RGB_SNORM16] = pack_float_SIGNED_RGB_16;
2209 table[MESA_FORMAT_RGBA_SNORM16] = pack_float_SIGNED_RGBA_16;
2210 table[MESA_FORMAT_A_SNORM8] = pack_float_SIGNED_A8;
2211 table[MESA_FORMAT_L_SNORM8] = pack_float_SIGNED_L8;
2212 table[MESA_FORMAT_L8A8_SNORM] = pack_float_SIGNED_AL88;
2213 table[MESA_FORMAT_I_SNORM8] = pack_float_SIGNED_L8; /* reused */
2214 table[MESA_FORMAT_A_SNORM16] = pack_float_SIGNED_A16;
2215 table[MESA_FORMAT_L_SNORM16] = pack_float_SIGNED_L16;
2216 table[MESA_FORMAT_LA_SNORM16] = pack_float_SIGNED_AL1616;
2217 table[MESA_FORMAT_I_SNORM16] = pack_float_SIGNED_L16; /* reused */
2218
2219 table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_float_RGB9_E5_FLOAT;
2220 table[MESA_FORMAT_R11G11B10_FLOAT] = pack_float_R11_G11_B10_FLOAT;
2221
2222 table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_float_XRGB4444_UNORM;
2223 table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_float_XRGB1555_UNORM;
2224 table[MESA_FORMAT_R8G8B8X8_SNORM] = pack_float_XBGR8888_SNORM;
2225 table[MESA_FORMAT_R8G8B8X8_SRGB] = pack_float_XBGR8888_SRGB;
2226 table[MESA_FORMAT_RGBX_UINT8] = NULL;
2227 table[MESA_FORMAT_RGBX_SINT8] = NULL;
2228 table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_float_XRGB2101010_UNORM;
2229 table[MESA_FORMAT_RGBX_UNORM16] = pack_float_XBGR16161616_UNORM;
2230 table[MESA_FORMAT_RGBX_SNORM16] = pack_float_XBGR16161616_SNORM;
2231 table[MESA_FORMAT_RGBX_FLOAT16] = pack_float_XBGR16161616_FLOAT;
2232 table[MESA_FORMAT_RGBX_UINT16] = NULL;
2233 table[MESA_FORMAT_RGBX_SINT16] = NULL;
2234 table[MESA_FORMAT_RGBX_FLOAT32] = pack_float_XBGR32323232_FLOAT;
2235 table[MESA_FORMAT_RGBX_UINT32] = NULL;
2236 table[MESA_FORMAT_RGBX_SINT32] = NULL;
2237
2238 table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_float_ABGR2101010;
2239
2240 table[MESA_FORMAT_G8R8_SNORM] = pack_float_SIGNED_RG88;
2241 table[MESA_FORMAT_G16R16_SNORM] = pack_float_SIGNED_RG1616;
2242
2243 table[MESA_FORMAT_B8G8R8X8_SRGB] = pack_float_XRGB8888_SRGB;
2244
2245 initialized = GL_TRUE;
2246 }
2247
2248 return table[format];
2249 }
2250
2251
2252
2253 static pack_float_rgba_row_func
2254 get_pack_float_rgba_row_function(mesa_format format)
2255 {
2256 static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
2257 static GLboolean initialized = GL_FALSE;
2258
2259 if (!initialized) {
2260 /* We don't need a special row packing function for each format.
2261 * There's a generic fallback which uses a per-pixel packing function.
2262 */
2263 memset(table, 0, sizeof(table));
2264
2265 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_float_RGBA8888;
2266 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_float_RGBA8888_REV;
2267 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_float_ARGB8888;
2268 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_float_ARGB8888_REV;
2269 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_float_RGBA8888; /* reused */
2270 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_float_RGBA8888_REV; /* reused */
2271 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_float_XRGB8888;
2272 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_float_XRGB8888_REV;
2273 table[MESA_FORMAT_BGR_UNORM8] = pack_row_float_RGB888;
2274 table[MESA_FORMAT_RGB_UNORM8] = pack_row_float_BGR888;
2275 table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_float_RGB565;
2276 table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_float_RGB565_REV;
2277
2278 initialized = GL_TRUE;
2279 }
2280
2281 return table[format];
2282 }
2283
2284
2285
2286 static pack_ubyte_rgba_row_func
2287 get_pack_ubyte_rgba_row_function(mesa_format format)
2288 {
2289 static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
2290 static GLboolean initialized = GL_FALSE;
2291
2292 if (!initialized) {
2293 /* We don't need a special row packing function for each format.
2294 * There's a generic fallback which uses a per-pixel packing function.
2295 */
2296 memset(table, 0, sizeof(table));
2297
2298 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888;
2299 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_ubyte_RGBA8888_REV;
2300 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_ubyte_ARGB8888;
2301 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_ubyte_ARGB8888_REV;
2302 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_ubyte_RGBA8888; /* reused */
2303 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_ubyte_RGBA8888_REV; /* reused */
2304 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_ubyte_XRGB8888;
2305 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_ubyte_XRGB8888_REV;
2306 table[MESA_FORMAT_BGR_UNORM8] = pack_row_ubyte_RGB888;
2307 table[MESA_FORMAT_RGB_UNORM8] = pack_row_ubyte_BGR888;
2308 table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_ubyte_RGB565;
2309 table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_ubyte_RGB565_REV;
2310
2311 initialized = GL_TRUE;
2312 }
2313
2314 return table[format];
2315 }
2316
2317
2318
2319 /**
2320 * Pack a row of GLfloat rgba[4] values to the destination.
2321 */
2322 void
2323 _mesa_pack_float_rgba_row(mesa_format format, GLuint n,
2324 const GLfloat src[][4], void *dst)
2325 {
2326 pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
2327 if (packrow) {
2328 /* use "fast" function */
2329 packrow(n, src, dst);
2330 }
2331 else {
2332 /* slower fallback */
2333 gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
2334 GLuint dstStride = _mesa_get_format_bytes(format);
2335 GLubyte *dstPtr = (GLubyte *) dst;
2336 GLuint i;
2337
2338 assert(pack);
2339 if (!pack)
2340 return;
2341
2342 for (i = 0; i < n; i++) {
2343 pack(src[i], dstPtr);
2344 dstPtr += dstStride;
2345 }
2346 }
2347 }
2348
2349
2350 /**
2351 * Pack a row of GLubyte rgba[4] values to the destination.
2352 */
2353 void
2354 _mesa_pack_ubyte_rgba_row(mesa_format format, GLuint n,
2355 const GLubyte src[][4], void *dst)
2356 {
2357 pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2358 if (packrow) {
2359 /* use "fast" function */
2360 packrow(n, src, dst);
2361 }
2362 else {
2363 /* slower fallback */
2364 gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
2365 const GLuint stride = _mesa_get_format_bytes(format);
2366 GLubyte *d = ((GLubyte *) dst);
2367 GLuint i;
2368
2369 assert(pack);
2370 if (!pack)
2371 return;
2372
2373 for (i = 0; i < n; i++) {
2374 pack(src[i], d);
2375 d += stride;
2376 }
2377 }
2378 }
2379
2380
2381 /**
2382 * Pack a 2D image of ubyte RGBA pixels in the given format.
2383 * \param srcRowStride source image row stride in bytes
2384 * \param dstRowStride destination image row stride in bytes
2385 */
2386 void
2387 _mesa_pack_ubyte_rgba_rect(mesa_format format, GLuint width, GLuint height,
2388 const GLubyte *src, GLint srcRowStride,
2389 void *dst, GLint dstRowStride)
2390 {
2391 pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2392 GLubyte *dstUB = (GLubyte *) dst;
2393 GLuint i;
2394
2395 if (packrow) {
2396 if (srcRowStride == width * 4 * sizeof(GLubyte) &&
2397 dstRowStride == _mesa_format_row_stride(format, width)) {
2398 /* do whole image at once */
2399 packrow(width * height, (const GLubyte (*)[4]) src, dst);
2400 }
2401 else {
2402 /* row by row */
2403 for (i = 0; i < height; i++) {
2404 packrow(width, (const GLubyte (*)[4]) src, dstUB);
2405 src += srcRowStride;
2406 dstUB += dstRowStride;
2407 }
2408 }
2409 }
2410 else {
2411 /* slower fallback */
2412 for (i = 0; i < height; i++) {
2413 _mesa_pack_ubyte_rgba_row(format, width,
2414 (const GLubyte (*)[4]) src, dstUB);
2415 src += srcRowStride;
2416 dstUB += dstRowStride;
2417 }
2418 }
2419 }
2420
2421
2422
2423 /**
2424 ** Pack float Z pixels
2425 **/
2426
2427 static void
2428 pack_float_z_Z24_S8(const GLfloat *src, void *dst)
2429 {
2430 /* don't disturb the stencil values */
2431 GLuint *d = ((GLuint *) dst);
2432 const GLdouble scale = (GLdouble) 0xffffff;
2433 GLuint s = *d & 0xff;
2434 GLuint z = (GLuint) (*src * scale);
2435 assert(z <= 0xffffff);
2436 *d = (z << 8) | s;
2437 }
2438
2439 static void
2440 pack_float_z_S8_Z24(const GLfloat *src, void *dst)
2441 {
2442 /* don't disturb the stencil values */
2443 GLuint *d = ((GLuint *) dst);
2444 const GLdouble scale = (GLdouble) 0xffffff;
2445 GLuint s = *d & 0xff000000;
2446 GLuint z = (GLuint) (*src * scale);
2447 assert(z <= 0xffffff);
2448 *d = s | z;
2449 }
2450
2451 static void
2452 pack_float_z_Z16(const GLfloat *src, void *dst)
2453 {
2454 GLushort *d = ((GLushort *) dst);
2455 const GLfloat scale = (GLfloat) 0xffff;
2456 *d = (GLushort) (*src * scale);
2457 }
2458
2459 static void
2460 pack_float_z_Z32(const GLfloat *src, void *dst)
2461 {
2462 GLuint *d = ((GLuint *) dst);
2463 const GLdouble scale = (GLdouble) 0xffffffff;
2464 *d = (GLuint) (*src * scale);
2465 }
2466
2467 static void
2468 pack_float_z_Z32_FLOAT(const GLfloat *src, void *dst)
2469 {
2470 GLfloat *d = (GLfloat *) dst;
2471 *d = *src;
2472 }
2473
2474 gl_pack_float_z_func
2475 _mesa_get_pack_float_z_func(mesa_format format)
2476 {
2477 switch (format) {
2478 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2479 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2480 return pack_float_z_Z24_S8;
2481 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2482 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2483 return pack_float_z_S8_Z24;
2484 case MESA_FORMAT_Z_UNORM16:
2485 return pack_float_z_Z16;
2486 case MESA_FORMAT_Z_UNORM32:
2487 return pack_float_z_Z32;
2488 case MESA_FORMAT_Z_FLOAT32:
2489 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2490 return pack_float_z_Z32_FLOAT;
2491 default:
2492 _mesa_problem(NULL,
2493 "unexpected format in _mesa_get_pack_float_z_func()");
2494 return NULL;
2495 }
2496 }
2497
2498
2499
2500 /**
2501 ** Pack uint Z pixels. The incoming src value is always in
2502 ** the range [0, 2^32-1].
2503 **/
2504
2505 static void
2506 pack_uint_z_Z24_S8(const GLuint *src, void *dst)
2507 {
2508 /* don't disturb the stencil values */
2509 GLuint *d = ((GLuint *) dst);
2510 GLuint s = *d & 0xff;
2511 GLuint z = *src & 0xffffff00;
2512 *d = z | s;
2513 }
2514
2515 static void
2516 pack_uint_z_S8_Z24(const GLuint *src, void *dst)
2517 {
2518 /* don't disturb the stencil values */
2519 GLuint *d = ((GLuint *) dst);
2520 GLuint s = *d & 0xff000000;
2521 GLuint z = *src >> 8;
2522 *d = s | z;
2523 }
2524
2525 static void
2526 pack_uint_z_Z16(const GLuint *src, void *dst)
2527 {
2528 GLushort *d = ((GLushort *) dst);
2529 *d = *src >> 16;
2530 }
2531
2532 static void
2533 pack_uint_z_Z32(const GLuint *src, void *dst)
2534 {
2535 GLuint *d = ((GLuint *) dst);
2536 *d = *src;
2537 }
2538
2539 static void
2540 pack_uint_z_Z32_FLOAT(const GLuint *src, void *dst)
2541 {
2542 GLuint *d = ((GLuint *) dst);
2543 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2544 *d = (GLuint) (*src * scale);
2545 assert(*d >= 0.0f);
2546 assert(*d <= 1.0f);
2547 }
2548
2549 static void
2550 pack_uint_z_Z32_FLOAT_X24S8(const GLuint *src, void *dst)
2551 {
2552 GLfloat *d = ((GLfloat *) dst);
2553 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2554 *d = (GLfloat) (*src * scale);
2555 assert(*d >= 0.0f);
2556 assert(*d <= 1.0f);
2557 }
2558
2559 gl_pack_uint_z_func
2560 _mesa_get_pack_uint_z_func(mesa_format format)
2561 {
2562 switch (format) {
2563 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2564 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2565 return pack_uint_z_Z24_S8;
2566 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2567 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2568 return pack_uint_z_S8_Z24;
2569 case MESA_FORMAT_Z_UNORM16:
2570 return pack_uint_z_Z16;
2571 case MESA_FORMAT_Z_UNORM32:
2572 return pack_uint_z_Z32;
2573 case MESA_FORMAT_Z_FLOAT32:
2574 return pack_uint_z_Z32_FLOAT;
2575 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2576 return pack_uint_z_Z32_FLOAT_X24S8;
2577 default:
2578 _mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
2579 return NULL;
2580 }
2581 }
2582
2583
2584 /**
2585 ** Pack ubyte stencil pixels
2586 **/
2587
2588 static void
2589 pack_ubyte_stencil_Z24_S8(const GLubyte *src, void *dst)
2590 {
2591 /* don't disturb the Z values */
2592 GLuint *d = ((GLuint *) dst);
2593 GLuint s = *src;
2594 GLuint z = *d & 0xffffff00;
2595 *d = z | s;
2596 }
2597
2598 static void
2599 pack_ubyte_stencil_S8_Z24(const GLubyte *src, void *dst)
2600 {
2601 /* don't disturb the Z values */
2602 GLuint *d = ((GLuint *) dst);
2603 GLuint s = *src << 24;
2604 GLuint z = *d & 0xffffff;
2605 *d = s | z;
2606 }
2607
2608 static void
2609 pack_ubyte_stencil_S8(const GLubyte *src, void *dst)
2610 {
2611 GLubyte *d = (GLubyte *) dst;
2612 *d = *src;
2613 }
2614
2615 static void
2616 pack_ubyte_stencil_Z32_FLOAT_X24S8(const GLubyte *src, void *dst)
2617 {
2618 GLfloat *d = ((GLfloat *) dst);
2619 d[1] = *src;
2620 }
2621
2622
2623 gl_pack_ubyte_stencil_func
2624 _mesa_get_pack_ubyte_stencil_func(mesa_format format)
2625 {
2626 switch (format) {
2627 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2628 return pack_ubyte_stencil_Z24_S8;
2629 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2630 return pack_ubyte_stencil_S8_Z24;
2631 case MESA_FORMAT_S_UINT8:
2632 return pack_ubyte_stencil_S8;
2633 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2634 return pack_ubyte_stencil_Z32_FLOAT_X24S8;
2635 default:
2636 _mesa_problem(NULL,
2637 "unexpected format in _mesa_pack_ubyte_stencil_func()");
2638 return NULL;
2639 }
2640 }
2641
2642
2643
2644 void
2645 _mesa_pack_float_z_row(mesa_format format, GLuint n,
2646 const GLfloat *src, void *dst)
2647 {
2648 switch (format) {
2649 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2650 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2651 {
2652 /* don't disturb the stencil values */
2653 GLuint *d = ((GLuint *) dst);
2654 const GLdouble scale = (GLdouble) 0xffffff;
2655 GLuint i;
2656 for (i = 0; i < n; i++) {
2657 GLuint s = d[i] & 0xff;
2658 GLuint z = (GLuint) (src[i] * scale);
2659 assert(z <= 0xffffff);
2660 d[i] = (z << 8) | s;
2661 }
2662 }
2663 break;
2664 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2665 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2666 {
2667 /* don't disturb the stencil values */
2668 GLuint *d = ((GLuint *) dst);
2669 const GLdouble scale = (GLdouble) 0xffffff;
2670 GLuint i;
2671 for (i = 0; i < n; i++) {
2672 GLuint s = d[i] & 0xff000000;
2673 GLuint z = (GLuint) (src[i] * scale);
2674 assert(z <= 0xffffff);
2675 d[i] = s | z;
2676 }
2677 }
2678 break;
2679 case MESA_FORMAT_Z_UNORM16:
2680 {
2681 GLushort *d = ((GLushort *) dst);
2682 const GLfloat scale = (GLfloat) 0xffff;
2683 GLuint i;
2684 for (i = 0; i < n; i++) {
2685 d[i] = (GLushort) (src[i] * scale);
2686 }
2687 }
2688 break;
2689 case MESA_FORMAT_Z_UNORM32:
2690 {
2691 GLuint *d = ((GLuint *) dst);
2692 const GLdouble scale = (GLdouble) 0xffffffff;
2693 GLuint i;
2694 for (i = 0; i < n; i++) {
2695 d[i] = (GLuint) (src[i] * scale);
2696 }
2697 }
2698 break;
2699 case MESA_FORMAT_Z_FLOAT32:
2700 memcpy(dst, src, n * sizeof(GLfloat));
2701 break;
2702 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2703 {
2704 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2705 GLuint i;
2706 for (i = 0; i < n; i++) {
2707 d[i].z = src[i];
2708 }
2709 }
2710 break;
2711 default:
2712 _mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
2713 }
2714 }
2715
2716
2717 /**
2718 * The incoming Z values are always in the range [0, 0xffffffff].
2719 */
2720 void
2721 _mesa_pack_uint_z_row(mesa_format format, GLuint n,
2722 const GLuint *src, void *dst)
2723 {
2724 switch (format) {
2725 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2726 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2727 {
2728 /* don't disturb the stencil values */
2729 GLuint *d = ((GLuint *) dst);
2730 GLuint i;
2731 for (i = 0; i < n; i++) {
2732 GLuint s = d[i] & 0xff;
2733 GLuint z = src[i] & 0xffffff00;
2734 d[i] = z | s;
2735 }
2736 }
2737 break;
2738 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2739 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2740 {
2741 /* don't disturb the stencil values */
2742 GLuint *d = ((GLuint *) dst);
2743 GLuint i;
2744 for (i = 0; i < n; i++) {
2745 GLuint s = d[i] & 0xff000000;
2746 GLuint z = src[i] >> 8;
2747 d[i] = s | z;
2748 }
2749 }
2750 break;
2751 case MESA_FORMAT_Z_UNORM16:
2752 {
2753 GLushort *d = ((GLushort *) dst);
2754 GLuint i;
2755 for (i = 0; i < n; i++) {
2756 d[i] = src[i] >> 16;
2757 }
2758 }
2759 break;
2760 case MESA_FORMAT_Z_UNORM32:
2761 memcpy(dst, src, n * sizeof(GLfloat));
2762 break;
2763 case MESA_FORMAT_Z_FLOAT32:
2764 {
2765 GLuint *d = ((GLuint *) dst);
2766 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2767 GLuint i;
2768 for (i = 0; i < n; i++) {
2769 d[i] = (GLuint) (src[i] * scale);
2770 assert(d[i] >= 0.0f);
2771 assert(d[i] <= 1.0f);
2772 }
2773 }
2774 break;
2775 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2776 {
2777 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2778 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2779 GLuint i;
2780 for (i = 0; i < n; i++) {
2781 d[i].z = (GLfloat) (src[i] * scale);
2782 assert(d[i].z >= 0.0f);
2783 assert(d[i].z <= 1.0f);
2784 }
2785 }
2786 break;
2787 default:
2788 _mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
2789 }
2790 }
2791
2792
2793 void
2794 _mesa_pack_ubyte_stencil_row(mesa_format format, GLuint n,
2795 const GLubyte *src, void *dst)
2796 {
2797 switch (format) {
2798 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2799 {
2800 /* don't disturb the Z values */
2801 GLuint *d = ((GLuint *) dst);
2802 GLuint i;
2803 for (i = 0; i < n; i++) {
2804 GLuint s = src[i];
2805 GLuint z = d[i] & 0xffffff00;
2806 d[i] = z | s;
2807 }
2808 }
2809 break;
2810 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2811 {
2812 /* don't disturb the Z values */
2813 GLuint *d = ((GLuint *) dst);
2814 GLuint i;
2815 for (i = 0; i < n; i++) {
2816 GLuint s = src[i] << 24;
2817 GLuint z = d[i] & 0xffffff;
2818 d[i] = s | z;
2819 }
2820 }
2821 break;
2822 case MESA_FORMAT_S_UINT8:
2823 memcpy(dst, src, n * sizeof(GLubyte));
2824 break;
2825 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2826 {
2827 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2828 GLuint i;
2829 for (i = 0; i < n; i++) {
2830 d[i].x24s8 = src[i];
2831 }
2832 }
2833 break;
2834 default:
2835 _mesa_problem(NULL, "unexpected format in _mesa_pack_ubyte_stencil_row()");
2836 }
2837 }
2838
2839
2840 /**
2841 * Incoming Z/stencil values are always in uint_24_8 format.
2842 */
2843 void
2844 _mesa_pack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
2845 const GLuint *src, void *dst)
2846 {
2847 switch (format) {
2848 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2849 memcpy(dst, src, n * sizeof(GLuint));
2850 break;
2851 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2852 {
2853 GLuint *d = ((GLuint *) dst);
2854 GLuint i;
2855 for (i = 0; i < n; i++) {
2856 GLuint s = src[i] << 24;
2857 GLuint z = src[i] >> 8;
2858 d[i] = s | z;
2859 }
2860 }
2861 break;
2862 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2863 {
2864 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
2865 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2866 GLuint i;
2867 for (i = 0; i < n; i++) {
2868 GLfloat z = (GLfloat) ((src[i] >> 8) * scale);
2869 d[i].z = z;
2870 d[i].x24s8 = src[i];
2871 }
2872 }
2873 break;
2874 default:
2875 _mesa_problem(NULL, "bad format %s in _mesa_pack_ubyte_s_row",
2876 _mesa_get_format_name(format));
2877 return;
2878 }
2879 }
2880
2881
2882
2883 /**
2884 * Convert a boolean color mask to a packed color where each channel of
2885 * the packed value at dst will be 0 or ~0 depending on the colorMask.
2886 */
2887 void
2888 _mesa_pack_colormask(mesa_format format, const GLubyte colorMask[4], void *dst)
2889 {
2890 GLfloat maskColor[4];
2891
2892 switch (_mesa_get_format_datatype(format)) {
2893 case GL_UNSIGNED_NORMALIZED:
2894 /* simple: 1.0 will convert to ~0 in the right bit positions */
2895 maskColor[0] = colorMask[0] ? 1.0f : 0.0f;
2896 maskColor[1] = colorMask[1] ? 1.0f : 0.0f;
2897 maskColor[2] = colorMask[2] ? 1.0f : 0.0f;
2898 maskColor[3] = colorMask[3] ? 1.0f : 0.0f;
2899 _mesa_pack_float_rgba_row(format, 1,
2900 (const GLfloat (*)[4]) maskColor, dst);
2901 break;
2902 case GL_SIGNED_NORMALIZED:
2903 case GL_FLOAT:
2904 /* These formats are harder because it's hard to know the floating
2905 * point values that will convert to ~0 for each color channel's bits.
2906 * This solution just generates a non-zero value for each color channel
2907 * then fixes up the non-zero values to be ~0.
2908 * Note: we'll need to add special case code if we ever have to deal
2909 * with formats with unequal color channel sizes, like R11_G11_B10.
2910 * We issue a warning below for channel sizes other than 8,16,32.
2911 */
2912 {
2913 GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
2914 GLuint bytes = _mesa_get_format_bytes(format);
2915 GLuint i;
2916
2917 /* this should put non-zero values into the channels of dst */
2918 maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
2919 maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
2920 maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
2921 maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
2922 _mesa_pack_float_rgba_row(format, 1,
2923 (const GLfloat (*)[4]) maskColor, dst);
2924
2925 /* fix-up the dst channels by converting non-zero values to ~0 */
2926 if (bits == 8) {
2927 GLubyte *d = (GLubyte *) dst;
2928 for (i = 0; i < bytes; i++) {
2929 d[i] = d[i] ? 0xff : 0x0;
2930 }
2931 }
2932 else if (bits == 16) {
2933 GLushort *d = (GLushort *) dst;
2934 for (i = 0; i < bytes / 2; i++) {
2935 d[i] = d[i] ? 0xffff : 0x0;
2936 }
2937 }
2938 else if (bits == 32) {
2939 GLuint *d = (GLuint *) dst;
2940 for (i = 0; i < bytes / 4; i++) {
2941 d[i] = d[i] ? 0xffffffffU : 0x0;
2942 }
2943 }
2944 else {
2945 _mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
2946 return;
2947 }
2948 }
2949 break;
2950 default:
2951 _mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
2952 return;
2953 }
2954 }