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