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