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