projects / reactos.git / blob
? search:


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