projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
main/format_pack: Fix a wrong datatype in pack_ubyte_R8G8_UNORM
[mesa.git] / src / mesa / main / format_pack.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (c) 2011 VMware, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * Color, depth, stencil packing functions.
28 * Used to pack basic color, depth and stencil formats to specific
29 * hardware formats.
30 *
31 * There are both per-pixel and per-row packing functions:
32 * - The former will be used by swrast to write values to the color, depth,
33 * stencil buffers when drawing points, lines and masked spans.
34 * - The later will be used for image-oriented functions like glDrawPixels,
35 * glAccum, and glTexImage.
36 */
37
38
39 #include "colormac.h"
40 #include "format_pack.h"
41 #include "macros.h"
42 #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
43 #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
44
45
46 /** Helper struct for MESA_FORMAT_Z32_FLOAT_S8X24_UINT */
47 struct z32f_x24s8
48 {
49 float z;
50 uint32_t x24s8;
51 };
52
53
54 typedef void (*pack_ubyte_rgba_row_func)(GLuint n,
55 const GLubyte src[][4], void *dst);
56
57 typedef void (*pack_float_rgba_row_func)(GLuint n,
58 const GLfloat src[][4], void *dst);
59
60
61
62 static inline GLfloat
63 linear_to_srgb(GLfloat cl)
64 {
65 if (cl < 0.0f)
66 return 0.0f;
67 else if (cl < 0.0031308f)
68 return 12.92f * cl;
69 else if (cl < 1.0f)
70 return 1.055f * powf(cl, 0.41666f) - 0.055f;
71 else
72 return 1.0f;
73 }
74
75
76 static inline GLubyte
77 linear_float_to_srgb_ubyte(GLfloat cl)
78 {
79 GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl));
80 return res;
81 }
82
83
84 static inline GLubyte
85 linear_ubyte_to_srgb_ubyte(GLubyte cl)
86 {
87 GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl / 255.0f));
88 return res;
89 }
90
91
92
93
94 /*
95 * MESA_FORMAT_A8B8G8R8_UNORM
96 */
97
98 static void
99 pack_ubyte_A8B8G8R8_UNORM(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_A8B8G8R8_UNORM(const GLfloat src[4], void *dst)
107 {
108 GLubyte v[4];
109 _mesa_unclamped_float_rgba_to_ubyte(v, src);
110 pack_ubyte_A8B8G8R8_UNORM(v, dst);
111 }
112
113 static void
114 pack_row_ubyte_A8B8G8R8_UNORM(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_A8B8G8R8_UNORM(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_A8B8G8R8_UNORM(v, d + i);
133 }
134 }
135
136
137
138 /*
139 * MESA_FORMAT_R8G8B8A8_UNORM
140 */
141
142 static void
143 pack_ubyte_R8G8B8A8_UNORM(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_R8G8B8A8_UNORM(const GLfloat src[4], void *dst)
151 {
152 GLubyte v[4];
153 _mesa_unclamped_float_rgba_to_ubyte(v, src);
154 pack_ubyte_R8G8B8A8_UNORM(v, dst);
155 }
156
157 static void
158 pack_row_ubyte_R8G8B8A8_UNORM(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_R8G8B8A8_UNORM(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_R8G8B8A8_UNORM(v, d + i);
177 }
178 }
179
180
181 /*
182 * MESA_FORMAT_B8G8R8A8_UNORM
183 */
184
185 static void
186 pack_ubyte_B8G8R8A8_UNORM(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_B8G8R8A8_UNORM(const GLfloat src[4], void *dst)
194 {
195 GLubyte v[4];
196 _mesa_unclamped_float_rgba_to_ubyte(v, src);
197 pack_ubyte_B8G8R8A8_UNORM(v, dst);
198 }
199
200 static void
201 pack_row_ubyte_B8G8R8A8_UNORM(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_B8G8R8A8_UNORM(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_B8G8R8A8_UNORM(v, d + i);
220 }
221 }
222
223
224 /*
225 * MESA_FORMAT_A8R8G8B8_UNORM
226 */
227
228 static void
229 pack_ubyte_A8R8G8B8_UNORM(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_A8R8G8B8_UNORM(const GLfloat src[4], void *dst)
237 {
238 GLubyte v[4];
239 _mesa_unclamped_float_rgba_to_ubyte(v, src);
240 pack_ubyte_A8R8G8B8_UNORM(v, dst);
241 }
242
243 static void
244 pack_row_ubyte_A8R8G8B8_UNORM(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_A8R8G8B8_UNORM(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_A8R8G8B8_UNORM(v, d + i);
263 }
264 }
265
266
267 /*
268 * MESA_FORMAT_B8G8R8X8_UNORM
269 */
270
271 static void
272 pack_ubyte_B8G8R8X8_UNORM(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_B8G8R8X8_UNORM(const GLfloat src[4], void *dst)
280 {
281 GLubyte v[4];
282 _mesa_unclamped_float_rgba_to_ubyte(v, src);
283 pack_ubyte_B8G8R8X8_UNORM(v, dst);
284 }
285
286 static void
287 pack_row_ubyte_B8G8R8X8_UNORM(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_B8G8R8X8_UNORM(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_B8G8R8X8_UNORM(v, d + i);
305 }
306 }
307
308
309 /*
310 * MESA_FORMAT_X8R8G8B8_UNORM
311 */
312
313 static void
314 pack_ubyte_X8R8G8B8_UNORM(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_X8R8G8B8_UNORM(const GLfloat src[4], void *dst)
322 {
323 GLubyte v[4];
324 _mesa_unclamped_float_rgba_to_ubyte(v, src);
325 pack_ubyte_X8R8G8B8_UNORM(v, dst);
326 }
327
328 static void
329 pack_row_ubyte_X8R8G8B8_UNORM(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_X8R8G8B8_UNORM(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_X8R8G8B8_UNORM(v, d + i);
347 }
348 }
349
350
351 /*
352 * MESA_FORMAT_BGR_UNORM8
353 */
354
355 static void
356 pack_ubyte_BGR_UNORM8(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_BGR_UNORM8(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_BGR_UNORM8(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_BGR_UNORM8(GLuint n, const GLfloat src[][4], void *dst)
387 {
388 GLubyte *d = ((GLubyte *) dst);
389 GLuint i;
390 for (i = 0; i < n; i++) {
391 GLubyte v[4];
392 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
393 d[i*3+2] = v[RCOMP];
394 d[i*3+1] = v[GCOMP];
395 d[i*3+0] = v[BCOMP];
396 }
397 }
398
399
400 /*
401 * MESA_FORMAT_RGB_UNORM8
402 */
403
404 static void
405 pack_ubyte_RGB_UNORM8(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_RGB_UNORM8(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_RGB_UNORM8(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_RGB_UNORM8(GLuint n, const GLfloat src[][4], void *dst)
436 {
437 GLubyte *d = ((GLubyte *) dst);
438 GLuint i;
439 for (i = 0; i < n; i++) {
440 GLubyte v[4];
441 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
442 d[i*3+2] = v[BCOMP];
443 d[i*3+1] = v[GCOMP];
444 d[i*3+0] = v[RCOMP];
445 }
446 }
447
448
449 /*
450 * MESA_FORMAT_B5G6R5_UNORM
451 */
452
453 static void
454 pack_ubyte_B5G6R5_UNORM(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_B5G6R5_UNORM(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_B5G6R5_UNORM(v, dst);
468 }
469
470 static void
471 pack_row_ubyte_B5G6R5_UNORM(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_B5G6R5_UNORM(src[i], d + i);
477 }
478 }
479
480 static void
481 pack_row_float_B5G6R5_UNORM(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_B5G6R5_UNORM(v, d + i);
489 }
490 }
491
492
493 /*
494 * MESA_FORMAT_R5G6B5_UNORM
495 * Warning: these functions do not match the current Mesa definition
496 * of MESA_FORMAT_R5G6B5_UNORM.
497 */
498
499 static void
500 pack_ubyte_R5G6B5_UNORM(const GLubyte src[4], void *dst)
501 {
502 GLushort *d = ((GLushort *) dst);
503 *d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
504 }
505
506 static void
507 pack_float_R5G6B5_UNORM(const GLfloat src[4], void *dst)
508 {
509 GLushort *d = ((GLushort *) dst);
510 GLubyte r, g, b;
511 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
512 UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
513 UNCLAMPED_FLOAT_TO_UBYTE(b, src[BCOMP]);
514 *d = PACK_COLOR_565_REV(r, g, b);
515 }
516
517 static void
518 pack_row_ubyte_R5G6B5_UNORM(GLuint n, const GLubyte src[][4], void *dst)
519 {
520 GLushort *d = ((GLushort *) dst);
521 GLuint i;
522 for (i = 0; i < n; i++) {
523 pack_ubyte_R5G6B5_UNORM(src[i], d + i);
524 }
525 }
526
527 static void
528 pack_row_float_R5G6B5_UNORM(GLuint n, const GLfloat src[][4], void *dst)
529 {
530 GLushort *d = ((GLushort *) dst);
531 GLuint i;
532 for (i = 0; i < n; i++) {
533 GLubyte v[4];
534 _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
535 pack_ubyte_R5G6B5_UNORM(v, d + i);
536 }
537 }
538
539
540 /*
541 * MESA_FORMAT_B4G4R4A4_UNORM
542 */
543
544 static void
545 pack_ubyte_B4G4R4A4_UNORM(const GLubyte src[4], void *dst)
546 {
547 GLushort *d = ((GLushort *) dst);
548 *d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
549 }
550
551 static void
552 pack_float_B4G4R4A4_UNORM(const GLfloat src[4], void *dst)
553 {
554 GLubyte v[4];
555 _mesa_unclamped_float_rgba_to_ubyte(v, src);
556 pack_ubyte_B4G4R4A4_UNORM(v, dst);
557 }
558
559 /* use fallback row packing functions */
560
561
562 /*
563 * MESA_FORMAT_A4R4G4B4_UNORM
564 */
565
566 static void
567 pack_ubyte_A4R4G4B4_UNORM(const GLubyte src[4], void *dst)
568 {
569 GLushort *d = ((GLushort *) dst);
570 *d = PACK_COLOR_4444(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
571 }
572
573 static void
574 pack_float_A4R4G4B4_UNORM(const GLfloat src[4], void *dst)
575 {
576 GLubyte v[4];
577 _mesa_unclamped_float_rgba_to_ubyte(v, src);
578 pack_ubyte_A4R4G4B4_UNORM(v, dst);
579 }
580
581 /* use fallback row packing functions */
582
583
584 /*
585 * MESA_FORMAT_A1B5G5R5_UNORM
586 */
587
588 static void
589 pack_ubyte_A1B5G5R5_UNORM(const GLubyte src[4], void *dst)
590 {
591 GLushort *d = ((GLushort *) dst);
592 *d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
593 }
594
595 static void
596 pack_float_A1B5G5R5_UNORM(const GLfloat src[4], void *dst)
597 {
598 GLubyte v[4];
599 _mesa_unclamped_float_rgba_to_ubyte(v, src);
600 pack_ubyte_A1B5G5R5_UNORM(v, dst);
601 }
602
603 /* use fallback row packing functions */
604
605
606 /*
607 * MESA_FORMAT_B5G5R5A1_UNORM
608 */
609
610 static void
611 pack_ubyte_B5G5R5A1_UNORM(const GLubyte src[4], void *dst)
612 {
613 GLushort *d = ((GLushort *) dst);
614 *d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
615 }
616
617 static void
618 pack_float_B5G5R5A1_UNORM(const GLfloat src[4], void *dst)
619 {
620 GLubyte v[4];
621 _mesa_unclamped_float_rgba_to_ubyte(v, src);
622 pack_ubyte_B5G5R5A1_UNORM(v, dst);
623 }
624
625
626 /* MESA_FORMAT_A1R5G5B5_UNORM
627 * Warning: these functions do not match the current Mesa definition
628 * of MESA_FORMAT_A1R5G5B5_UNORM.
629 */
630
631 static void
632 pack_ubyte_A1R5G5B5_UNORM(const GLubyte src[4], void *dst)
633 {
634 GLushort *d = ((GLushort *) dst), tmp;
635 tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
636 *d = (tmp >> 8) | (tmp << 8);
637 }
638
639 static void
640 pack_float_A1R5G5B5_UNORM(const GLfloat src[4], void *dst)
641 {
642 GLubyte v[4];
643 _mesa_unclamped_float_rgba_to_ubyte(v, src);
644 pack_ubyte_A1R5G5B5_UNORM(v, dst);
645 }
646
647
648 /* MESA_FORMAT_L4A4_UNORM */
649
650 static void
651 pack_ubyte_L4A4_UNORM(const GLubyte src[4], void *dst)
652 {
653 GLubyte *d = ((GLubyte *) dst);
654 *d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
655 }
656
657 static void
658 pack_float_L4A4_UNORM(const GLfloat src[4], void *dst)
659 {
660 GLubyte v[4];
661 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
662 UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
663 pack_ubyte_L4A4_UNORM(v, dst);
664 }
665
666
667 /* MESA_FORMAT_L8A8_UNORM */
668
669 static void
670 pack_ubyte_L8A8_UNORM(const GLubyte src[4], void *dst)
671 {
672 GLushort *d = ((GLushort *) dst);
673 *d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
674 }
675
676 static void
677 pack_float_L8A8_UNORM(const GLfloat src[4], void *dst)
678 {
679 GLubyte v[4];
680 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
681 UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
682 pack_ubyte_L8A8_UNORM(v, dst);
683 }
684
685
686 /* MESA_FORMAT_A8L8_UNORM */
687
688 static void
689 pack_ubyte_A8L8_UNORM(const GLubyte src[4], void *dst)
690 {
691 GLushort *d = ((GLushort *) dst);
692 *d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
693 }
694
695 static void
696 pack_float_A8L8_UNORM(const GLfloat src[4], void *dst)
697 {
698 GLubyte v[4];
699 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
700 UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
701 pack_ubyte_A8L8_UNORM(v, dst);
702 }
703
704
705 /* MESA_FORMAT_L16A16_UNORM */
706
707 static void
708 pack_ubyte_L16A16_UNORM(const GLubyte src[4], void *dst)
709 {
710 GLuint *d = ((GLuint *) dst);
711 GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
712 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
713 *d = PACK_COLOR_1616(a, l);
714 }
715
716 static void
717 pack_float_L16A16_UNORM(const GLfloat src[4], void *dst)
718 {
719 GLuint *d = ((GLuint *) dst);
720 GLushort l, a;
721 UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
722 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
723 *d = PACK_COLOR_1616(a, l);
724 }
725
726
727 /* MESA_FORMAT_A16L16_UNORM */
728
729 static void
730 pack_ubyte_A16L16_UNORM(const GLubyte src[4], void *dst)
731 {
732 GLuint *d = ((GLuint *) dst);
733 GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
734 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
735 *d = PACK_COLOR_1616(l, a);
736 }
737
738 static void
739 pack_float_A16L16_UNORM(const GLfloat src[4], void *dst)
740 {
741 GLuint *d = ((GLuint *) dst);
742 GLushort l, a;
743 UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
744 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
745 *d = PACK_COLOR_1616(l, a);
746 }
747
748
749 /* MESA_FORMAT_B2G3R3_UNORM */
750
751 static void
752 pack_ubyte_B2G3R3_UNORM(const GLubyte src[4], void *dst)
753 {
754 GLubyte *d = ((GLubyte *) dst);
755 *d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
756 }
757
758 static void
759 pack_float_B2G3R3_UNORM(const GLfloat src[4], void *dst)
760 {
761 GLubyte v[4];
762 UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
763 UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
764 UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
765 pack_ubyte_B2G3R3_UNORM(v, dst);
766 }
767
768
769 /* MESA_FORMAT_A_UNORM8 */
770
771 static void
772 pack_ubyte_A_UNORM8(const GLubyte src[4], void *dst)
773 {
774 GLubyte *d = ((GLubyte *) dst);
775 *d = src[ACOMP];
776 }
777
778 static void
779 pack_float_A_UNORM8(const GLfloat src[4], void *dst)
780 {
781 GLubyte *d = ((GLubyte *) dst);
782 UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
783 }
784
785
786 /* MESA_FORMAT_A_UNORM16 */
787
788 static void
789 pack_ubyte_A_UNORM16(const GLubyte src[4], void *dst)
790 {
791 GLushort *d = ((GLushort *) dst);
792 *d = UBYTE_TO_USHORT(src[ACOMP]);
793 }
794
795 static void
796 pack_float_A_UNORM16(const GLfloat src[4], void *dst)
797 {
798 GLushort *d = ((GLushort *) dst);
799 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
800 }
801
802
803 /* MESA_FORMAT_L_UNORM8 */
804
805 static void
806 pack_ubyte_L_UNORM8(const GLubyte src[4], void *dst)
807 {
808 GLubyte *d = ((GLubyte *) dst);
809 *d = src[RCOMP];
810 }
811
812 static void
813 pack_float_L_UNORM8(const GLfloat src[4], void *dst)
814 {
815 GLubyte *d = ((GLubyte *) dst);
816 UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
817 }
818
819
820 /* MESA_FORMAT_L_UNORM16 */
821
822 static void
823 pack_ubyte_L_UNORM16(const GLubyte src[4], void *dst)
824 {
825 GLushort *d = ((GLushort *) dst);
826 *d = UBYTE_TO_USHORT(src[RCOMP]);
827 }
828
829 static void
830 pack_float_L_UNORM16(const GLfloat src[4], void *dst)
831 {
832 GLushort *d = ((GLushort *) dst);
833 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
834 }
835
836
837 /* MESA_FORMAT_YCBCR */
838
839 static void
840 pack_ubyte_YCBCR(const GLubyte src[4], void *dst)
841 {
842 /* todo */
843 }
844
845 static void
846 pack_float_YCBCR(const GLfloat src[4], void *dst)
847 {
848 /* todo */
849 }
850
851
852 /* MESA_FORMAT_YCBCR_REV */
853
854 static void
855 pack_ubyte_YCBCR_REV(const GLubyte src[4], void *dst)
856 {
857 /* todo */
858 }
859
860 static void
861 pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
862 {
863 /* todo */
864 }
865
866
867 /* MESA_FORMAT_R_UNORM8 */
868
869 static void
870 pack_ubyte_R_UNORM8(const GLubyte src[4], void *dst)
871 {
872 GLubyte *d = ((GLubyte *) dst);
873 *d = src[RCOMP];
874 }
875
876 static void
877 pack_float_R_UNORM8(const GLfloat src[4], void *dst)
878 {
879 GLubyte *d = ((GLubyte *) dst);
880 GLubyte r;
881 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
882 d[0] = r;
883 }
884
885
886 /* MESA_FORMAT_R8G8_UNORM */
887
888 static void
889 pack_ubyte_R8G8_UNORM(const GLubyte src[4], void *dst)
890 {
891 GLushort *d = ((GLushort *) dst);
892 *d = PACK_COLOR_88(src[GCOMP], src[RCOMP]);
893 }
894
895 static void
896 pack_float_R8G8_UNORM(const GLfloat src[4], void *dst)
897 {
898 GLushort *d = ((GLushort *) dst);
899 GLubyte r, g;
900 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
901 UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
902 *d = PACK_COLOR_88(g, r);
903 }
904
905
906 /* MESA_FORMAT_G8R8_UNORM */
907
908 static void
909 pack_ubyte_G8R8_UNORM(const GLubyte src[4], void *dst)
910 {
911 GLubyte *d = ((GLubyte *) dst);
912 *d = PACK_COLOR_88(src[RCOMP], src[GCOMP]);
913 }
914
915 static void
916 pack_float_G8R8_UNORM(const GLfloat src[4], void *dst)
917 {
918 GLushort *d = ((GLushort *) dst);
919 GLubyte r, g;
920 UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
921 UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
922 *d = PACK_COLOR_88(r, g);
923 }
924
925
926 /* MESA_FORMAT_R_UNORM16 */
927
928 static void
929 pack_ubyte_R_UNORM16(const GLubyte src[4], void *dst)
930 {
931 GLushort *d = ((GLushort *) dst);
932 *d = UBYTE_TO_USHORT(src[RCOMP]);
933 }
934
935 static void
936 pack_float_R_UNORM16(const GLfloat src[4], void *dst)
937 {
938 GLushort *d = ((GLushort *) dst);
939 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
940 }
941
942
943 /* MESA_FORMAT_R16G16_UNORM */
944
945 static void
946 pack_ubyte_R16G16_UNORM(const GLubyte src[4], void *dst)
947 {
948 GLuint *d = ((GLuint *) dst);
949 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
950 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
951 *d = PACK_COLOR_1616(g, r);
952 }
953
954 static void
955 pack_float_R16G16_UNORM(const GLfloat src[4], void *dst)
956 {
957 GLuint *d = ((GLuint *) dst);
958 GLushort r, g;
959 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
960 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
961 *d = PACK_COLOR_1616(g, r);
962 }
963
964
965 /* MESA_FORMAT_G16R16_UNORM */
966
967 static void
968 pack_ubyte_G16R16_UNORM(const GLubyte src[4], void *dst)
969 {
970 GLuint *d = ((GLuint *) dst);
971 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
972 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
973 *d = PACK_COLOR_1616(r, g);
974 }
975
976
977 static void
978 pack_float_G16R16_UNORM(const GLfloat src[4], void *dst)
979 {
980 GLuint *d = ((GLuint *) dst);
981 GLushort r, g;
982 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
983 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
984 *d = PACK_COLOR_1616(r, g);
985 }
986
987
988 /* MESA_FORMAT_B10G10R10A2_UNORM */
989
990 static void
991 pack_ubyte_B10G10R10A2_UNORM(const GLubyte src[4], void *dst)
992 {
993 GLuint *d = ((GLuint *) dst);
994 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
995 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
996 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
997 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
998 *d = PACK_COLOR_2101010_US(a, r, g, b);
999 }
1000
1001 static void
1002 pack_float_B10G10R10A2_UNORM(const GLfloat src[4], void *dst)
1003 {
1004 GLuint *d = ((GLuint *) dst);
1005 GLushort r, g, b, a;
1006 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1007 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1008 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1009 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1010 *d = PACK_COLOR_2101010_US(a, r, g, b);
1011 }
1012
1013
1014 /* MESA_FORMAT_R10G10B10A2_UINT */
1015
1016 static void
1017 pack_ubyte_R10G10B10A2_UINT(const GLubyte src[4], void *dst)
1018 {
1019 GLuint *d = ((GLuint *) dst);
1020 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1021 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1022 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1023 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1024 *d = PACK_COLOR_2101010_US(a, b, g, r);
1025 }
1026
1027 static void
1028 pack_float_R10G10B10A2_UINT(const GLfloat src[4], void *dst)
1029 {
1030 GLuint *d = ((GLuint *) dst);
1031 GLushort r, g, b, a;
1032 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1033 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1034 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1035 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1036 *d = PACK_COLOR_2101010_US(a, b, g, r);
1037 }
1038
1039
1040 /* MESA_FORMAT_BGR_SRGB8 */
1041
1042 static void
1043 pack_ubyte_BGR_SRGB8(const GLubyte src[4], void *dst)
1044 {
1045 GLubyte *d = ((GLubyte *) dst);
1046 d[2] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1047 d[1] = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1048 d[0] = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1049 }
1050
1051 static void
1052 pack_float_BGR_SRGB8(const GLfloat src[4], void *dst)
1053 {
1054 GLubyte *d = ((GLubyte *) dst);
1055 d[2] = linear_float_to_srgb_ubyte(src[RCOMP]);
1056 d[1] = linear_float_to_srgb_ubyte(src[GCOMP]);
1057 d[0] = linear_float_to_srgb_ubyte(src[BCOMP]);
1058 }
1059
1060
1061 /* MESA_FORMAT_A8B8G8R8_SRGB */
1062
1063 static void
1064 pack_ubyte_A8B8G8R8_SRGB(const GLubyte src[4], void *dst)
1065 {
1066 GLuint *d = ((GLuint *) dst);
1067 GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1068 GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1069 GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1070 *d = PACK_COLOR_8888(r, g, b, src[ACOMP]);
1071 }
1072
1073 static void
1074 pack_float_A8B8G8R8_SRGB(const GLfloat src[4], void *dst)
1075 {
1076 GLuint *d = ((GLuint *) dst);
1077 GLubyte r, g, b, a;
1078 r = linear_float_to_srgb_ubyte(src[RCOMP]);
1079 g = linear_float_to_srgb_ubyte(src[GCOMP]);
1080 b = linear_float_to_srgb_ubyte(src[BCOMP]);
1081 UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1082 *d = PACK_COLOR_8888(r, g, b, a);
1083 }
1084
1085
1086 /* MESA_FORMAT_B8G8R8A8_SRGB */
1087
1088 static void
1089 pack_ubyte_B8G8R8A8_SRGB(const GLubyte src[4], void *dst)
1090 {
1091 GLuint *d = ((GLuint *) dst);
1092 GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1093 GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1094 GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1095 *d = PACK_COLOR_8888(src[ACOMP], r, g, b);
1096 }
1097
1098 static void
1099 pack_float_B8G8R8A8_SRGB(const GLfloat src[4], void *dst)
1100 {
1101 GLuint *d = ((GLuint *) dst);
1102 GLubyte r, g, b, a;
1103 r = linear_float_to_srgb_ubyte(src[RCOMP]);
1104 g = linear_float_to_srgb_ubyte(src[GCOMP]);
1105 b = linear_float_to_srgb_ubyte(src[BCOMP]);
1106 UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1107 *d = PACK_COLOR_8888(a, r, g, b);
1108 }
1109
1110
1111 /* MESA_FORMAT_R8G8B8A8_SRGB */
1112
1113 static void
1114 pack_ubyte_R8G8B8A8_SRGB(const GLubyte src[4], void *dst)
1115 {
1116 GLuint *d = ((GLuint *) dst);
1117 GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1118 GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
1119 GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
1120 *d = PACK_COLOR_8888(src[ACOMP], b, g, r);
1121 }
1122
1123 static void
1124 pack_float_R8G8B8A8_SRGB(const GLfloat src[4], void *dst)
1125 {
1126 GLuint *d = ((GLuint *) dst);
1127 GLubyte r, g, b, a;
1128 r = linear_float_to_srgb_ubyte(src[RCOMP]);
1129 g = linear_float_to_srgb_ubyte(src[GCOMP]);
1130 b = linear_float_to_srgb_ubyte(src[BCOMP]);
1131 UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1132 *d = PACK_COLOR_8888(a, b, g, r);
1133 }
1134
1135
1136 /* MESA_FORMAT_L_SRGB8 */
1137
1138 static void
1139 pack_ubyte_L_SRGB8(const GLubyte src[4], void *dst)
1140 {
1141 GLubyte *d = ((GLubyte *) dst);
1142 *d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1143 }
1144
1145 static void
1146 pack_float_L_SRGB8(const GLfloat src[4], void *dst)
1147 {
1148 GLubyte *d = ((GLubyte *) dst);
1149 GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
1150 *d = l;
1151 }
1152
1153
1154 /* MESA_FORMAT_L8A8_SRGB */
1155
1156 static void
1157 pack_ubyte_L8A8_SRGB(const GLubyte src[4], void *dst)
1158 {
1159 GLushort *d = ((GLushort *) dst);
1160 GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
1161 *d = PACK_COLOR_88(src[ACOMP], l);
1162 }
1163
1164 static void
1165 pack_float_L8A8_SRGB(const GLfloat src[4], void *dst)
1166 {
1167 GLushort *d = ((GLushort *) dst);
1168 GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
1169 CLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
1170 *d = PACK_COLOR_88(a, l);
1171 }
1172
1173
1174 /* MESA_FORMAT_RGBA_FLOAT32 */
1175
1176 static void
1177 pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
1178 {
1179 GLfloat *d = ((GLfloat *) dst);
1180 d[0] = UBYTE_TO_FLOAT(src[0]);
1181 d[1] = UBYTE_TO_FLOAT(src[1]);
1182 d[2] = UBYTE_TO_FLOAT(src[2]);
1183 d[3] = UBYTE_TO_FLOAT(src[3]);
1184 }
1185
1186 static void
1187 pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
1188 {
1189 GLfloat *d = ((GLfloat *) dst);
1190 d[0] = src[0];
1191 d[1] = src[1];
1192 d[2] = src[2];
1193 d[3] = src[3];
1194 }
1195
1196
1197 /* MESA_FORMAT_RGBA_FLOAT16 */
1198
1199 static void
1200 pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
1201 {
1202 GLhalfARB *d = ((GLhalfARB *) dst);
1203 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1204 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1205 d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1206 d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
1207 }
1208
1209 static void
1210 pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
1211 {
1212 GLhalfARB *d = ((GLhalfARB *) dst);
1213 d[0] = _mesa_float_to_half(src[0]);
1214 d[1] = _mesa_float_to_half(src[1]);
1215 d[2] = _mesa_float_to_half(src[2]);
1216 d[3] = _mesa_float_to_half(src[3]);
1217 }
1218
1219
1220 /* MESA_FORMAT_RGB_FLOAT32 */
1221
1222 static void
1223 pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
1224 {
1225 GLfloat *d = ((GLfloat *) dst);
1226 d[0] = UBYTE_TO_FLOAT(src[0]);
1227 d[1] = UBYTE_TO_FLOAT(src[1]);
1228 d[2] = UBYTE_TO_FLOAT(src[2]);
1229 }
1230
1231 static void
1232 pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
1233 {
1234 GLfloat *d = ((GLfloat *) dst);
1235 d[0] = src[0];
1236 d[1] = src[1];
1237 d[2] = src[2];
1238 }
1239
1240
1241 /* MESA_FORMAT_RGB_FLOAT16 */
1242
1243 static void
1244 pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
1245 {
1246 GLhalfARB *d = ((GLhalfARB *) dst);
1247 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
1248 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
1249 d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
1250 }
1251
1252 static void
1253 pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
1254 {
1255 GLhalfARB *d = ((GLhalfARB *) dst);
1256 d[0] = _mesa_float_to_half(src[0]);
1257 d[1] = _mesa_float_to_half(src[1]);
1258 d[2] = _mesa_float_to_half(src[2]);
1259 }
1260
1261
1262 /* MESA_FORMAT_A_FLOAT32 */
1263
1264 static void
1265 pack_ubyte_A_FLOAT32(const GLubyte src[4], void *dst)
1266 {
1267 GLfloat *d = ((GLfloat *) dst);
1268 d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
1269 }
1270
1271 static void
1272 pack_float_A_FLOAT32(const GLfloat src[4], void *dst)
1273 {
1274 GLfloat *d = ((GLfloat *) dst);
1275 d[0] = src[ACOMP];
1276 }
1277
1278
1279 /* MESA_FORMAT_A_FLOAT16 */
1280
1281 static void
1282 pack_ubyte_A_FLOAT16(const GLubyte src[4], void *dst)
1283 {
1284 GLhalfARB *d = ((GLhalfARB *) dst);
1285 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1286 }
1287
1288 static void
1289 pack_float_A_FLOAT16(const GLfloat src[4], void *dst)
1290 {
1291 GLhalfARB *d = ((GLhalfARB *) dst);
1292 d[0] = _mesa_float_to_half(src[ACOMP]);
1293 }
1294
1295
1296 /* MESA_FORMAT_L_FLOAT32 (and I_FLOAT32, R_FLOAT32) */
1297
1298 static void
1299 pack_ubyte_L_FLOAT32(const GLubyte src[4], void *dst)
1300 {
1301 GLfloat *d = ((GLfloat *) dst);
1302 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1303 }
1304
1305 static void
1306 pack_float_L_FLOAT32(const GLfloat src[4], void *dst)
1307 {
1308 GLfloat *d = ((GLfloat *) dst);
1309 d[0] = src[RCOMP];
1310 }
1311
1312
1313 /* MESA_FORMAT_L_FLOAT16 (and I_FLOAT16, R_FLOAT32) */
1314
1315 static void
1316 pack_ubyte_L_FLOAT16(const GLubyte src[4], void *dst)
1317 {
1318 GLhalfARB *d = ((GLhalfARB *) dst);
1319 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1320 }
1321
1322 static void
1323 pack_float_L_FLOAT16(const GLfloat src[4], void *dst)
1324 {
1325 GLhalfARB *d = ((GLhalfARB *) dst);
1326 d[0] = _mesa_float_to_half(src[RCOMP]);
1327 }
1328
1329
1330 /* MESA_FORMAT_LA_FLOAT32 */
1331
1332 static void
1333 pack_ubyte_LA_FLOAT32(const GLubyte src[4], void *dst)
1334 {
1335 GLfloat *d = ((GLfloat *) dst);
1336 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1337 d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
1338 }
1339
1340 static void
1341 pack_float_LA_FLOAT32(const GLfloat src[4], void *dst)
1342 {
1343 GLfloat *d = ((GLfloat *) dst);
1344 d[0] = src[RCOMP];
1345 d[1] = src[ACOMP];
1346 }
1347
1348
1349 /* MESA_FORMAT_LA_FLOAT16 */
1350
1351 static void
1352 pack_ubyte_LA_FLOAT16(const GLubyte src[4], void *dst)
1353 {
1354 GLhalfARB *d = ((GLhalfARB *) dst);
1355 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1356 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
1357 }
1358
1359 static void
1360 pack_float_LA_FLOAT16(const GLfloat src[4], void *dst)
1361 {
1362 GLhalfARB *d = ((GLhalfARB *) dst);
1363 d[0] = _mesa_float_to_half(src[RCOMP]);
1364 d[1] = _mesa_float_to_half(src[ACOMP]);
1365 }
1366
1367
1368 /* MESA_FORMAT_RG_FLOAT32 */
1369
1370 static void
1371 pack_ubyte_RG_FLOAT32(const GLubyte src[4], void *dst)
1372 {
1373 GLfloat *d = ((GLfloat *) dst);
1374 d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1375 d[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1376 }
1377
1378 static void
1379 pack_float_RG_FLOAT32(const GLfloat src[4], void *dst)
1380 {
1381 GLfloat *d = ((GLfloat *) dst);
1382 d[0] = src[RCOMP];
1383 d[1] = src[GCOMP];
1384 }
1385
1386
1387 /* MESA_FORMAT_RG_FLOAT16 */
1388
1389 static void
1390 pack_ubyte_RG_FLOAT16(const GLubyte src[4], void *dst)
1391 {
1392 GLhalfARB *d = ((GLhalfARB *) dst);
1393 d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
1394 d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[GCOMP]));
1395 }
1396
1397 static void
1398 pack_float_RG_FLOAT16(const GLfloat src[4], void *dst)
1399 {
1400 GLhalfARB *d = ((GLhalfARB *) dst);
1401 d[0] = _mesa_float_to_half(src[RCOMP]);
1402 d[1] = _mesa_float_to_half(src[GCOMP]);
1403 }
1404
1405
1406 /* MESA_FORMAT_RGBA_UNORM16 */
1407
1408 static void
1409 pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
1410 {
1411 GLushort *d = ((GLushort *) dst);
1412 d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1413 d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1414 d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1415 d[3] = UBYTE_TO_USHORT(src[ACOMP]);
1416 }
1417
1418 static void
1419 pack_float_RGBA_16(const GLfloat src[4], void *dst)
1420 {
1421 GLushort *d = ((GLushort *) dst);
1422 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1423 UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1424 UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1425 UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
1426 }
1427
1428
1429
1430 /*
1431 * MESA_FORMAT_R_SNORM8
1432 */
1433
1434 static void
1435 pack_float_R_SNORM8(const GLfloat src[4], void *dst)
1436 {
1437 GLbyte *d = (GLbyte *) dst;
1438 *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1439 }
1440
1441
1442 /*
1443 * MESA_FORMAT_R8G8_SNORM
1444 */
1445
1446 static void
1447 pack_float_R8G8_SNORM(const GLfloat src[4], void *dst)
1448 {
1449 GLushort *d = (GLushort *) 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 *d = (g << 8) | r;
1453 }
1454
1455
1456 /*
1457 * MESA_FORMAT_X8B8G8R8_SNORM
1458 */
1459
1460 static void
1461 pack_float_X8B8G8R8_SNORM(const GLfloat src[4], void *dst)
1462 {
1463 GLuint *d = (GLuint *) dst;
1464 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1465 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1466 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1467 GLbyte a = 127;
1468 *d = PACK_COLOR_8888(r, g, b, a);
1469 }
1470
1471
1472 /*
1473 * MESA_FORMAT_A8B8G8R8_SNORM
1474 */
1475
1476 static void
1477 pack_float_A8B8G8R8_SNORM(const GLfloat src[4], void *dst)
1478 {
1479 GLuint *d = (GLuint *) dst;
1480 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1481 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1482 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1483 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1484 *d = PACK_COLOR_8888(r, g, b, a);
1485 }
1486
1487
1488 /*
1489 * MESA_FORMAT_R8G8B8A8_SNORM
1490 */
1491
1492 static void
1493 pack_float_R8G8B8A8_SNORM(const GLfloat src[4], void *dst)
1494 {
1495 GLuint *d = (GLuint *) dst;
1496 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1497 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1498 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1499 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1500 *d = PACK_COLOR_8888(a, b, g, r);
1501 }
1502
1503
1504 /*
1505 * MESA_FORMAT_R_SNORM16
1506 */
1507
1508 static void
1509 pack_float_R_SNORM16(const GLfloat src[4], void *dst)
1510 {
1511 GLshort *d = (GLshort *) dst;
1512 *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1513 }
1514
1515
1516 /*
1517 * MESA_FORMAT_R16G16_SNORM
1518 */
1519
1520 static void
1521 pack_float_R16G16_SNORM(const GLfloat src[4], void *dst)
1522 {
1523 GLuint *d = (GLuint *) dst;
1524 GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1525 GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1526 *d = (g << 16) | (r & 0xffff);
1527 }
1528
1529
1530 /*
1531 * MESA_FORMAT_RGB_SNORM16
1532 */
1533
1534 static void
1535 pack_float_RGB_SNORM16(const GLfloat src[4], void *dst)
1536 {
1537 GLshort *d = (GLshort *) dst;
1538 d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1539 d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1540 d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1541 }
1542
1543
1544 /*
1545 * MESA_FORMAT_RGBA_SNORM16
1546 */
1547
1548 static void
1549 pack_float_RGBA_SNORM16(const GLfloat src[4], void *dst)
1550 {
1551 GLshort *d = (GLshort *) dst;
1552 d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1553 d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1554 d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
1555 d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1556 }
1557
1558
1559 /*
1560 * MESA_FORMAT_A_SNORM8
1561 */
1562
1563 static void
1564 pack_float_A_SNORM8(const GLfloat src[4], void *dst)
1565 {
1566 GLbyte *d = (GLbyte *) dst;
1567 *d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1568 }
1569
1570
1571 /*
1572 * MESA_FORMAT_L_SNORM8
1573 */
1574
1575 static void
1576 pack_float_L_SNORM8(const GLfloat src[4], void *dst)
1577 {
1578 GLbyte *d = (GLbyte *) dst;
1579 *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1580 }
1581
1582
1583 /*
1584 * MESA_FORMAT_L8A8_SNORM
1585 */
1586
1587 static void
1588 pack_float_L8A8_SNORM(const GLfloat src[4], void *dst)
1589 {
1590 GLushort *d = (GLushort *) dst;
1591 GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1592 GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
1593 *d = (a << 8) | l;
1594 }
1595
1596
1597 /*
1598 * MESA_FORMAT_A_SNORM16
1599 */
1600
1601 static void
1602 pack_float_A_SNORM16(const GLfloat src[4], void *dst)
1603 {
1604 GLshort *d = (GLshort *) dst;
1605 *d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1606 }
1607
1608
1609 /*
1610 * MESA_FORMAT_L_SNORM16
1611 */
1612
1613 static void
1614 pack_float_L_SNORM16(const GLfloat src[4], void *dst)
1615 {
1616 GLshort *d = (GLshort *) dst;
1617 *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1618 }
1619
1620
1621 /*
1622 * MESA_FORMAT_LA_SNORM16
1623 */
1624
1625 static void
1626 pack_float_LA_SNORM16(const GLfloat src[4], void *dst)
1627 {
1628 GLuint *d = (GLuint *) dst;
1629 GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1630 GLshort a = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
1631 *d = PACK_COLOR_1616(a, l);
1632 }
1633
1634
1635 /*
1636 * MESA_FORMAT_R9G9B9E5_FLOAT;
1637 */
1638
1639 static void
1640 pack_float_R9G9B9E5_FLOAT(const GLfloat src[4], void *dst)
1641 {
1642 GLuint *d = (GLuint *) dst;
1643 *d = float3_to_rgb9e5(src);
1644 }
1645
1646 static void
1647 pack_ubyte_R9G9B9E5_FLOAT(const GLubyte src[4], void *dst)
1648 {
1649 GLuint *d = (GLuint *) dst;
1650 GLfloat rgb[3];
1651 rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1652 rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1653 rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1654 *d = float3_to_rgb9e5(rgb);
1655 }
1656
1657
1658
1659 /*
1660 * MESA_FORMAT_R11G11B10_FLOAT;
1661 */
1662
1663 static void
1664 pack_ubyte_R11G11B10_FLOAT(const GLubyte src[4], void *dst)
1665 {
1666 GLuint *d = (GLuint *) dst;
1667 GLfloat rgb[3];
1668 rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
1669 rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
1670 rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
1671 *d = float3_to_r11g11b10f(rgb);
1672 }
1673
1674 static void
1675 pack_float_R11G11B10_FLOAT(const GLfloat src[4], void *dst)
1676 {
1677 GLuint *d = (GLuint *) dst;
1678 *d = float3_to_r11g11b10f(src);
1679 }
1680
1681
1682 /*
1683 * MESA_FORMAT_B4G4R4X4_UNORM
1684 */
1685
1686 static void
1687 pack_ubyte_XRGB4444_UNORM(const GLubyte src[4], void *dst)
1688 {
1689 GLushort *d = ((GLushort *) dst);
1690 *d = PACK_COLOR_4444(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1691 }
1692
1693 static void
1694 pack_float_XRGB4444_UNORM(const GLfloat src[4], void *dst)
1695 {
1696 GLubyte v[4];
1697 _mesa_unclamped_float_rgba_to_ubyte(v, src);
1698 pack_ubyte_XRGB4444_UNORM(v, dst);
1699 }
1700
1701
1702 /*
1703 * MESA_FORMAT_B5G5R5X1_UNORM
1704 */
1705
1706 static void
1707 pack_ubyte_XRGB1555_UNORM(const GLubyte src[4], void *dst)
1708 {
1709 GLushort *d = ((GLushort *) dst);
1710 *d = PACK_COLOR_1555(255, src[RCOMP], src[GCOMP], src[BCOMP]);
1711 }
1712
1713 static void
1714 pack_float_XRGB1555_UNORM(const GLfloat src[4], void *dst)
1715 {
1716 GLubyte v[4];
1717 _mesa_unclamped_float_rgba_to_ubyte(v, src);
1718 pack_ubyte_XRGB1555_UNORM(v, dst);
1719 }
1720
1721
1722 /*
1723 * MESA_FORMAT_R8G8B8X8_SNORM
1724 */
1725
1726 static void
1727 pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
1728 {
1729 GLuint *d = (GLuint *) dst;
1730 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1731 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1732 GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
1733 *d = PACK_COLOR_8888(127, b, g, r);
1734 }
1735
1736
1737 /*
1738 * MESA_FORMAT_R8G8B8X8_SRGB
1739 */
1740
1741 static void
1742 pack_float_R8G8B8X8_SRGB(const GLfloat src[4], void *dst)
1743 {
1744 GLuint *d = (GLuint *) dst;
1745 GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1746 GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1747 GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1748 *d = PACK_COLOR_8888(127, b, g, r);
1749 }
1750
1751
1752 /* MESA_FORMAT_B10G10R10X2_UNORM */
1753
1754 static void
1755 pack_ubyte_B10G10R10X2_UNORM(const GLubyte src[4], void *dst)
1756 {
1757 GLuint *d = ((GLuint *) dst);
1758 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1759 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1760 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1761 *d = PACK_COLOR_2101010_US(3, r, g, b);
1762 }
1763
1764 static void
1765 pack_float_B10G10R10X2_UNORM(const GLfloat src[4], void *dst)
1766 {
1767 GLuint *d = ((GLuint *) dst);
1768 GLushort r, g, b;
1769 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1770 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1771 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1772 *d = PACK_COLOR_2101010_US(3, r, g, b);
1773 }
1774
1775
1776 /* MESA_FORMAT_RGBX_UNORM16 */
1777
1778 static void
1779 pack_ubyte_RGBX_UNORM16(const GLubyte src[4], void *dst)
1780 {
1781 GLushort *d = ((GLushort *) dst);
1782 d[0] = UBYTE_TO_USHORT(src[RCOMP]);
1783 d[1] = UBYTE_TO_USHORT(src[GCOMP]);
1784 d[2] = UBYTE_TO_USHORT(src[BCOMP]);
1785 d[3] = 65535;
1786 }
1787
1788 static void
1789 pack_float_RGBX_UNORM16(const GLfloat src[4], void *dst)
1790 {
1791 GLushort *d = ((GLushort *) dst);
1792 UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
1793 UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
1794 UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
1795 d[3] = 65535;
1796 }
1797
1798
1799 /* MESA_FORMAT_RGBX_SNORM16 */
1800
1801 static void
1802 pack_float_RGBX_SNORM16(const GLfloat src[4], void *dst)
1803 {
1804 GLushort *d = ((GLushort *) dst);
1805 UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
1806 UNCLAMPED_FLOAT_TO_SHORT(d[1], src[GCOMP]);
1807 UNCLAMPED_FLOAT_TO_SHORT(d[2], src[BCOMP]);
1808 d[3] = 32767;
1809 }
1810
1811
1812 /* MESA_FORMAT_RGBX_FLOAT16 */
1813
1814 static void
1815 pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
1816 {
1817 GLushort *d = ((GLushort *) dst);
1818 d[0] = _mesa_float_to_half(src[RCOMP]);
1819 d[1] = _mesa_float_to_half(src[GCOMP]);
1820 d[2] = _mesa_float_to_half(src[BCOMP]);
1821 d[3] = _mesa_float_to_half(1.0);
1822 }
1823
1824 /* MESA_FORMAT_RGBX_FLOAT32 */
1825
1826 static void
1827 pack_float_RGBX_FLOAT32(const GLfloat src[4], void *dst)
1828 {
1829 GLfloat *d = ((GLfloat *) dst);
1830 d[0] = src[RCOMP];
1831 d[1] = src[GCOMP];
1832 d[2] = src[BCOMP];
1833 d[3] = 1.0;
1834 }
1835
1836 /* MESA_FORMAT_R10G10B10A2_UNORM */
1837
1838 static void
1839 pack_ubyte_R10G10B10A2_UNORM(const GLubyte src[4], void *dst)
1840 {
1841 GLuint *d = ((GLuint *) dst);
1842 GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
1843 GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
1844 GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
1845 GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
1846 *d = PACK_COLOR_2101010_US(a, b, g, r);
1847 }
1848
1849 static void
1850 pack_float_R10G10B10A2_UNORM(const GLfloat src[4], void *dst)
1851 {
1852 GLuint *d = ((GLuint *) dst);
1853 GLushort r, g, b, a;
1854 UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
1855 UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
1856 UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
1857 UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
1858 *d = PACK_COLOR_2101010_US(a, b, g, r);
1859 }
1860
1861 /*
1862 * MESA_FORMAT_G8R8_SNORM
1863 */
1864
1865 static void
1866 pack_float_G8R8_SNORM(const GLfloat src[4], void *dst)
1867 {
1868 GLushort *d = (GLushort *) dst;
1869 GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
1870 GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
1871 *d = (r << 8) | (g & 0xff);
1872 }
1873
1874 /*
1875 * MESA_FORMAT_G16R16_SNORM
1876 */
1877
1878 static void
1879 pack_float_G16R16_SNORM(const GLfloat src[4], void *dst)
1880 {
1881 GLuint *d = (GLuint *) dst;
1882 GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
1883 GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
1884 *d = (r << 16) | (g & 0xffff);
1885 }
1886
1887 /*
1888 * MESA_FORMAT_B8G8R8X8_SRGB
1889 */
1890
1891 static void
1892 pack_float_B8G8R8X8_SRGB(const GLfloat src[4], void *dst)
1893 {
1894 GLuint *d = (GLuint *) dst;
1895 GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
1896 GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
1897 GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
1898 *d = PACK_COLOR_8888(127, r, g, b);
1899 }
1900
1901 /**
1902 * Return a function that can pack a GLubyte rgba[4] color.
1903 */
1904 gl_pack_ubyte_rgba_func
1905 _mesa_get_pack_ubyte_rgba_function(mesa_format format)
1906 {
1907 static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
1908 static GLboolean initialized = GL_FALSE;
1909
1910 if (!initialized) {
1911 memset(table, 0, sizeof(table));
1912
1913 table[MESA_FORMAT_NONE] = NULL;
1914
1915 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_ubyte_A8B8G8R8_UNORM;
1916 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_ubyte_R8G8B8A8_UNORM;
1917 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_ubyte_B8G8R8A8_UNORM;
1918 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_ubyte_A8R8G8B8_UNORM;
1919 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_ubyte_A8B8G8R8_UNORM; /* reused */
1920 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_ubyte_R8G8B8A8_UNORM; /* reused */
1921 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_ubyte_B8G8R8X8_UNORM;
1922 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_ubyte_X8R8G8B8_UNORM;
1923 table[MESA_FORMAT_BGR_UNORM8] = pack_ubyte_BGR_UNORM8;
1924 table[MESA_FORMAT_RGB_UNORM8] = pack_ubyte_RGB_UNORM8;
1925 table[MESA_FORMAT_B5G6R5_UNORM] = pack_ubyte_B5G6R5_UNORM;
1926 table[MESA_FORMAT_R5G6B5_UNORM] = pack_ubyte_R5G6B5_UNORM;
1927 table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_ubyte_B4G4R4A4_UNORM;
1928 table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_ubyte_A4R4G4B4_UNORM;
1929 table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_ubyte_A1B5G5R5_UNORM;
1930 table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_ubyte_B5G5R5A1_UNORM;
1931 table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_ubyte_A1R5G5B5_UNORM;
1932 table[MESA_FORMAT_L4A4_UNORM] = pack_ubyte_L4A4_UNORM;
1933 table[MESA_FORMAT_L8A8_UNORM] = pack_ubyte_L8A8_UNORM;
1934 table[MESA_FORMAT_A8L8_UNORM] = pack_ubyte_A8L8_UNORM;
1935 table[MESA_FORMAT_L16A16_UNORM] = pack_ubyte_L16A16_UNORM;
1936 table[MESA_FORMAT_A16L16_UNORM] = pack_ubyte_A16L16_UNORM;
1937 table[MESA_FORMAT_B2G3R3_UNORM] = pack_ubyte_B2G3R3_UNORM;
1938 table[MESA_FORMAT_A_UNORM8] = pack_ubyte_A_UNORM8;
1939 table[MESA_FORMAT_A_UNORM16] = pack_ubyte_A_UNORM16;
1940 table[MESA_FORMAT_L_UNORM8] = pack_ubyte_L_UNORM8;
1941 table[MESA_FORMAT_L_UNORM16] = pack_ubyte_L_UNORM16;
1942 table[MESA_FORMAT_I_UNORM8] = pack_ubyte_L_UNORM8; /* reuse pack_ubyte_L_UNORM8 */
1943 table[MESA_FORMAT_I_UNORM16] = pack_ubyte_L_UNORM16; /* reuse pack_ubyte_L_UNORM16 */
1944 table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
1945 table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
1946 table[MESA_FORMAT_R_UNORM8] = pack_ubyte_R_UNORM8;
1947 table[MESA_FORMAT_R8G8_UNORM] = pack_ubyte_R8G8_UNORM;
1948 table[MESA_FORMAT_G8R8_UNORM] = pack_ubyte_G8R8_UNORM;
1949 table[MESA_FORMAT_R_UNORM16] = pack_ubyte_R_UNORM16;
1950 table[MESA_FORMAT_R16G16_UNORM] = pack_ubyte_R16G16_UNORM;
1951 table[MESA_FORMAT_G16R16_UNORM] = pack_ubyte_G16R16_UNORM;
1952 table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_ubyte_B10G10R10A2_UNORM;
1953 table[MESA_FORMAT_R10G10B10A2_UINT] = pack_ubyte_R10G10B10A2_UINT;
1954
1955 /* should never convert RGBA to these formats */
1956 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
1957 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
1958 table[MESA_FORMAT_Z_UNORM16] = NULL;
1959 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
1960 table[MESA_FORMAT_X8_UINT_Z24_UNORM] = NULL;
1961 table[MESA_FORMAT_Z_UNORM32] = NULL;
1962 table[MESA_FORMAT_S_UINT8] = NULL;
1963
1964 /* sRGB */
1965 table[MESA_FORMAT_BGR_SRGB8] = pack_ubyte_BGR_SRGB8;
1966 table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_ubyte_A8B8G8R8_SRGB;
1967 table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_ubyte_B8G8R8A8_SRGB;
1968 table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_ubyte_R8G8B8A8_SRGB;
1969 table[MESA_FORMAT_L_SRGB8] = pack_ubyte_L_SRGB8;
1970 table[MESA_FORMAT_L8A8_SRGB] = pack_ubyte_L8A8_SRGB;
1971 /* n/a */
1972 table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
1973 table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
1974 table[MESA_FORMAT_SRGBA_DXT3] = NULL; /* pack_ubyte_SRGBA_DXT3; */
1975 table[MESA_FORMAT_SRGBA_DXT5] = NULL; /* pack_ubyte_SRGBA_DXT5; */
1976
1977 table[MESA_FORMAT_RGB_FXT1] = NULL; /* pack_ubyte_RGB_FXT1; */
1978 table[MESA_FORMAT_RGBA_FXT1] = NULL; /* pack_ubyte_RGBA_FXT1; */
1979 table[MESA_FORMAT_RGB_DXT1] = NULL; /* pack_ubyte_RGB_DXT1; */
1980 table[MESA_FORMAT_RGBA_DXT1] = NULL; /* pack_ubyte_RGBA_DXT1; */
1981 table[MESA_FORMAT_RGBA_DXT3] = NULL; /* pack_ubyte_RGBA_DXT3; */
1982 table[MESA_FORMAT_RGBA_DXT5] = NULL; /* pack_ubyte_RGBA_DXT5; */
1983
1984 table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
1985 table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
1986 table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
1987 table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
1988 table[MESA_FORMAT_A_FLOAT32] = pack_ubyte_A_FLOAT32;
1989 table[MESA_FORMAT_A_FLOAT16] = pack_ubyte_A_FLOAT16;
1990 table[MESA_FORMAT_L_FLOAT32] = pack_ubyte_L_FLOAT32;
1991 table[MESA_FORMAT_L_FLOAT16] = pack_ubyte_L_FLOAT16;
1992 table[MESA_FORMAT_LA_FLOAT32] = pack_ubyte_LA_FLOAT32;
1993 table[MESA_FORMAT_LA_FLOAT16] = pack_ubyte_LA_FLOAT16;
1994 table[MESA_FORMAT_I_FLOAT32] = pack_ubyte_L_FLOAT32;
1995 table[MESA_FORMAT_I_FLOAT16] = pack_ubyte_L_FLOAT16;
1996 table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_L_FLOAT32;
1997 table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_L_FLOAT16;
1998 table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
1999 table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
2000
2001 /* n/a */
2002 table[MESA_FORMAT_RGBA_SINT8] = NULL; /* pack_ubyte_RGBA_INT8 */
2003 table[MESA_FORMAT_RGBA_SINT16] = NULL; /* pack_ubyte_RGBA_INT16 */
2004 table[MESA_FORMAT_RGBA_SINT32] = NULL; /* pack_ubyte_RGBA_INT32 */
2005 table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
2006 table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
2007 table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
2008
2009 table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2010
2011 /* n/a */
2012 table[MESA_FORMAT_R_SNORM8] = NULL;
2013 table[MESA_FORMAT_R8G8_SNORM] = NULL;
2014 table[MESA_FORMAT_X8B8G8R8_SNORM] = NULL;
2015 table[MESA_FORMAT_A8B8G8R8_SNORM] = NULL;
2016 table[MESA_FORMAT_R8G8B8A8_SNORM] = NULL;
2017 table[MESA_FORMAT_R_SNORM16] = NULL;
2018 table[MESA_FORMAT_R16G16_SNORM] = NULL;
2019 table[MESA_FORMAT_RGB_SNORM16] = NULL;
2020 table[MESA_FORMAT_RGBA_SNORM16] = NULL;
2021 table[MESA_FORMAT_A_SNORM8] = NULL;
2022 table[MESA_FORMAT_L_SNORM8] = NULL;
2023 table[MESA_FORMAT_L8A8_SNORM] = NULL;
2024 table[MESA_FORMAT_I_SNORM8] = NULL;
2025 table[MESA_FORMAT_A_SNORM16] = NULL;
2026 table[MESA_FORMAT_L_SNORM16] = NULL;
2027 table[MESA_FORMAT_LA_SNORM16] = NULL;
2028 table[MESA_FORMAT_I_SNORM16] = NULL;
2029
2030
2031 table[MESA_FORMAT_RGBA_UNORM16] = pack_ubyte_RGBA_16;
2032
2033 table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_ubyte_R9G9B9E5_FLOAT;
2034 table[MESA_FORMAT_R11G11B10_FLOAT] = pack_ubyte_R11G11B10_FLOAT;
2035
2036 table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_ubyte_XRGB4444_UNORM;
2037 table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_ubyte_XRGB1555_UNORM;
2038 table[MESA_FORMAT_R8G8B8X8_SNORM] = NULL;
2039 table[MESA_FORMAT_R8G8B8X8_SRGB] = NULL;
2040 table[MESA_FORMAT_RGBX_UINT8] = NULL;
2041 table[MESA_FORMAT_RGBX_SINT8] = NULL;
2042 table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_ubyte_B10G10R10X2_UNORM;
2043 table[MESA_FORMAT_RGBX_UNORM16] = pack_ubyte_RGBX_UNORM16;
2044 table[MESA_FORMAT_RGBX_SNORM16] = NULL;
2045 table[MESA_FORMAT_RGBX_FLOAT16] = NULL;
2046 table[MESA_FORMAT_RGBX_UINT16] = NULL;
2047 table[MESA_FORMAT_RGBX_SINT16] = NULL;
2048 table[MESA_FORMAT_RGBX_FLOAT32] = NULL;
2049 table[MESA_FORMAT_RGBX_UINT32] = NULL;
2050 table[MESA_FORMAT_RGBX_SINT32] = NULL;
2051
2052 table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_ubyte_R10G10B10A2_UNORM;
2053
2054 table[MESA_FORMAT_B8G8R8X8_SRGB] = NULL;
2055
2056 initialized = GL_TRUE;
2057 }
2058
2059 return table[format];
2060 }
2061
2062
2063
2064 /**
2065 * Return a function that can pack a GLfloat rgba[4] color.
2066 */
2067 gl_pack_float_rgba_func
2068 _mesa_get_pack_float_rgba_function(mesa_format format)
2069 {
2070 static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
2071 static GLboolean initialized = GL_FALSE;
2072
2073 if (!initialized) {
2074 memset(table, 0, sizeof(table));
2075
2076 table[MESA_FORMAT_NONE] = NULL;
2077
2078 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_float_A8B8G8R8_UNORM;
2079 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_float_R8G8B8A8_UNORM;
2080 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_float_B8G8R8A8_UNORM;
2081 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_float_A8R8G8B8_UNORM;
2082 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_float_A8B8G8R8_UNORM; /* reused */
2083 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_float_R8G8B8A8_UNORM; /* reused */
2084 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_float_B8G8R8X8_UNORM;
2085 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_float_X8R8G8B8_UNORM;
2086 table[MESA_FORMAT_BGR_UNORM8] = pack_float_BGR_UNORM8;
2087 table[MESA_FORMAT_RGB_UNORM8] = pack_float_RGB_UNORM8;
2088 table[MESA_FORMAT_B5G6R5_UNORM] = pack_float_B5G6R5_UNORM;
2089 table[MESA_FORMAT_R5G6B5_UNORM] = pack_float_R5G6B5_UNORM;
2090 table[MESA_FORMAT_B4G4R4A4_UNORM] = pack_float_B4G4R4A4_UNORM;
2091 table[MESA_FORMAT_A4R4G4B4_UNORM] = pack_float_A4R4G4B4_UNORM;
2092 table[MESA_FORMAT_A1B5G5R5_UNORM] = pack_float_A1B5G5R5_UNORM;
2093 table[MESA_FORMAT_B5G5R5A1_UNORM] = pack_float_B5G5R5A1_UNORM;
2094 table[MESA_FORMAT_A1R5G5B5_UNORM] = pack_float_A1R5G5B5_UNORM;
2095
2096 table[MESA_FORMAT_L4A4_UNORM] = pack_float_L4A4_UNORM;
2097 table[MESA_FORMAT_L8A8_UNORM] = pack_float_L8A8_UNORM;
2098 table[MESA_FORMAT_A8L8_UNORM] = pack_float_A8L8_UNORM;
2099 table[MESA_FORMAT_L16A16_UNORM] = pack_float_L16A16_UNORM;
2100 table[MESA_FORMAT_A16L16_UNORM] = pack_float_A16L16_UNORM;
2101 table[MESA_FORMAT_B2G3R3_UNORM] = pack_float_B2G3R3_UNORM;
2102 table[MESA_FORMAT_A_UNORM8] = pack_float_A_UNORM8;
2103 table[MESA_FORMAT_A_UNORM16] = pack_float_A_UNORM16;
2104 table[MESA_FORMAT_L_UNORM8] = pack_float_L_UNORM8;
2105 table[MESA_FORMAT_L_UNORM16] = pack_float_L_UNORM16;
2106 table[MESA_FORMAT_I_UNORM8] = pack_float_L_UNORM8; /* reuse pack_float_L_UNORM8 */
2107 table[MESA_FORMAT_I_UNORM16] = pack_float_L_UNORM16; /* reuse pack_float_L_UNORM16 */
2108 table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
2109 table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
2110 table[MESA_FORMAT_R_UNORM8] = pack_float_R_UNORM8;
2111 table[MESA_FORMAT_R8G8_UNORM] = pack_float_R8G8_UNORM;
2112 table[MESA_FORMAT_G8R8_UNORM] = pack_float_G8R8_UNORM;
2113 table[MESA_FORMAT_R_UNORM16] = pack_float_R_UNORM16;
2114 table[MESA_FORMAT_R16G16_UNORM] = pack_float_R16G16_UNORM;
2115 table[MESA_FORMAT_G16R16_UNORM] = pack_float_G16R16_UNORM;
2116 table[MESA_FORMAT_B10G10R10A2_UNORM] = pack_float_B10G10R10A2_UNORM;
2117 table[MESA_FORMAT_R10G10B10A2_UINT] = pack_float_R10G10B10A2_UINT;
2118
2119 /* should never convert RGBA to these formats */
2120 table[MESA_FORMAT_S8_UINT_Z24_UNORM] = NULL;
2121 table[MESA_FORMAT_Z24_UNORM_S8_UINT] = NULL;
2122 table[MESA_FORMAT_Z_UNORM16] = NULL;
2123 table[MESA_FORMAT_Z24_UNORM_X8_UINT] = NULL;
2124 table[MESA_FORMAT_X8_UINT_Z24_UNORM] = NULL;
2125 table[MESA_FORMAT_Z_UNORM32] = NULL;
2126 table[MESA_FORMAT_S_UINT8] = NULL;
2127
2128 table[MESA_FORMAT_BGR_SRGB8] = pack_float_BGR_SRGB8;
2129 table[MESA_FORMAT_A8B8G8R8_SRGB] = pack_float_A8B8G8R8_SRGB;
2130 table[MESA_FORMAT_B8G8R8A8_SRGB] = pack_float_B8G8R8A8_SRGB;
2131 table[MESA_FORMAT_R8G8B8A8_SRGB] = pack_float_R8G8B8A8_SRGB;
2132 table[MESA_FORMAT_L_SRGB8] = pack_float_L_SRGB8;
2133 table[MESA_FORMAT_L8A8_SRGB] = pack_float_L8A8_SRGB;
2134
2135 /* n/a */
2136 table[MESA_FORMAT_SRGB_DXT1] = NULL;
2137 table[MESA_FORMAT_SRGBA_DXT1] = NULL;
2138 table[MESA_FORMAT_SRGBA_DXT3] = NULL;
2139 table[MESA_FORMAT_SRGBA_DXT5] = NULL;
2140
2141 table[MESA_FORMAT_RGB_FXT1] = NULL;
2142 table[MESA_FORMAT_RGBA_FXT1] = NULL;
2143 table[MESA_FORMAT_RGB_DXT1] = NULL;
2144 table[MESA_FORMAT_RGBA_DXT1] = NULL;
2145 table[MESA_FORMAT_RGBA_DXT3] = NULL;
2146 table[MESA_FORMAT_RGBA_DXT5] = NULL;
2147
2148 table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
2149 table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
2150 table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
2151 table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
2152 table[MESA_FORMAT_A_FLOAT32] = pack_float_A_FLOAT32;
2153 table[MESA_FORMAT_A_FLOAT16] = pack_float_A_FLOAT16;
2154 table[MESA_FORMAT_L_FLOAT32] = pack_float_L_FLOAT32;
2155 table[MESA_FORMAT_L_FLOAT16] = pack_float_L_FLOAT16;
2156 table[MESA_FORMAT_LA_FLOAT32] = pack_float_LA_FLOAT32;
2157 table[MESA_FORMAT_LA_FLOAT16] = pack_float_LA_FLOAT16;
2158
2159 table[MESA_FORMAT_I_FLOAT32] = pack_float_L_FLOAT32;
2160 table[MESA_FORMAT_I_FLOAT16] = pack_float_L_FLOAT16;
2161 table[MESA_FORMAT_R_FLOAT32] = pack_float_L_FLOAT32;
2162 table[MESA_FORMAT_R_FLOAT16] = pack_float_L_FLOAT16;
2163 table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
2164 table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
2165
2166 /* n/a */
2167 table[MESA_FORMAT_RGBA_SINT8] = NULL;
2168 table[MESA_FORMAT_RGBA_SINT16] = NULL;
2169 table[MESA_FORMAT_RGBA_SINT32] = NULL;
2170 table[MESA_FORMAT_RGBA_UINT8] = NULL;
2171 table[MESA_FORMAT_RGBA_UINT16] = NULL;
2172 table[MESA_FORMAT_RGBA_UINT32] = NULL;
2173
2174 table[MESA_FORMAT_RGBA_UNORM16] = pack_float_RGBA_16;
2175
2176 table[MESA_FORMAT_R_SNORM8] = pack_float_R_SNORM8;
2177 table[MESA_FORMAT_R8G8_SNORM] = pack_float_R8G8_SNORM;
2178 table[MESA_FORMAT_X8B8G8R8_SNORM] = pack_float_X8B8G8R8_SNORM;
2179 table[MESA_FORMAT_A8B8G8R8_SNORM] = pack_float_A8B8G8R8_SNORM;
2180 table[MESA_FORMAT_R8G8B8A8_SNORM] = pack_float_R8G8B8A8_SNORM;
2181 table[MESA_FORMAT_R_SNORM16] = pack_float_R_SNORM16;
2182 table[MESA_FORMAT_R16G16_SNORM] = pack_float_R16G16_SNORM;
2183 table[MESA_FORMAT_RGB_SNORM16] = pack_float_RGB_SNORM16;
2184 table[MESA_FORMAT_RGBA_SNORM16] = pack_float_RGBA_SNORM16;
2185 table[MESA_FORMAT_A_SNORM8] = pack_float_A_SNORM8;
2186 table[MESA_FORMAT_L_SNORM8] = pack_float_L_SNORM8;
2187 table[MESA_FORMAT_L8A8_SNORM] = pack_float_L8A8_SNORM;
2188 table[MESA_FORMAT_I_SNORM8] = pack_float_L_SNORM8; /* reused */
2189 table[MESA_FORMAT_A_SNORM16] = pack_float_A_SNORM16;
2190 table[MESA_FORMAT_L_SNORM16] = pack_float_L_SNORM16;
2191 table[MESA_FORMAT_LA_SNORM16] = pack_float_LA_SNORM16;
2192 table[MESA_FORMAT_I_SNORM16] = pack_float_L_SNORM16; /* reused */
2193
2194 table[MESA_FORMAT_R9G9B9E5_FLOAT] = pack_float_R9G9B9E5_FLOAT;
2195 table[MESA_FORMAT_R11G11B10_FLOAT] = pack_float_R11G11B10_FLOAT;
2196
2197 table[MESA_FORMAT_B4G4R4X4_UNORM] = pack_float_XRGB4444_UNORM;
2198 table[MESA_FORMAT_B5G5R5X1_UNORM] = pack_float_XRGB1555_UNORM;
2199 table[MESA_FORMAT_R8G8B8X8_SNORM] = pack_float_XBGR8888_SNORM;
2200 table[MESA_FORMAT_R8G8B8X8_SRGB] = pack_float_R8G8B8X8_SRGB;
2201 table[MESA_FORMAT_RGBX_UINT8] = NULL;
2202 table[MESA_FORMAT_RGBX_SINT8] = NULL;
2203 table[MESA_FORMAT_B10G10R10X2_UNORM] = pack_float_B10G10R10X2_UNORM;
2204 table[MESA_FORMAT_RGBX_UNORM16] = pack_float_RGBX_UNORM16;
2205 table[MESA_FORMAT_RGBX_SNORM16] = pack_float_RGBX_SNORM16;
2206 table[MESA_FORMAT_RGBX_FLOAT16] = pack_float_XBGR16161616_FLOAT;
2207 table[MESA_FORMAT_RGBX_UINT16] = NULL;
2208 table[MESA_FORMAT_RGBX_SINT16] = NULL;
2209 table[MESA_FORMAT_RGBX_FLOAT32] = pack_float_RGBX_FLOAT32;
2210 table[MESA_FORMAT_RGBX_UINT32] = NULL;
2211 table[MESA_FORMAT_RGBX_SINT32] = NULL;
2212
2213 table[MESA_FORMAT_R10G10B10A2_UNORM] = pack_float_R10G10B10A2_UNORM;
2214
2215 table[MESA_FORMAT_G8R8_SNORM] = pack_float_G8R8_SNORM;
2216 table[MESA_FORMAT_G16R16_SNORM] = pack_float_G16R16_SNORM;
2217
2218 table[MESA_FORMAT_B8G8R8X8_SRGB] = pack_float_B8G8R8X8_SRGB;
2219
2220 initialized = GL_TRUE;
2221 }
2222
2223 return table[format];
2224 }
2225
2226
2227
2228 static pack_float_rgba_row_func
2229 get_pack_float_rgba_row_function(mesa_format format)
2230 {
2231 static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
2232 static GLboolean initialized = GL_FALSE;
2233
2234 if (!initialized) {
2235 /* We don't need a special row packing function for each format.
2236 * There's a generic fallback which uses a per-pixel packing function.
2237 */
2238 memset(table, 0, sizeof(table));
2239
2240 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_float_A8B8G8R8_UNORM;
2241 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_float_R8G8B8A8_UNORM;
2242 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_float_B8G8R8A8_UNORM;
2243 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_float_A8R8G8B8_UNORM;
2244 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_float_A8B8G8R8_UNORM; /* reused */
2245 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_float_R8G8B8A8_UNORM; /* reused */
2246 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_float_B8G8R8X8_UNORM;
2247 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_float_X8R8G8B8_UNORM;
2248 table[MESA_FORMAT_BGR_UNORM8] = pack_row_float_BGR_UNORM8;
2249 table[MESA_FORMAT_RGB_UNORM8] = pack_row_float_RGB_UNORM8;
2250 table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_float_B5G6R5_UNORM;
2251 table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_float_R5G6B5_UNORM;
2252
2253 initialized = GL_TRUE;
2254 }
2255
2256 return table[format];
2257 }
2258
2259
2260
2261 static pack_ubyte_rgba_row_func
2262 get_pack_ubyte_rgba_row_function(mesa_format format)
2263 {
2264 static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
2265 static GLboolean initialized = GL_FALSE;
2266
2267 if (!initialized) {
2268 /* We don't need a special row packing function for each format.
2269 * There's a generic fallback which uses a per-pixel packing function.
2270 */
2271 memset(table, 0, sizeof(table));
2272
2273 table[MESA_FORMAT_A8B8G8R8_UNORM] = pack_row_ubyte_A8B8G8R8_UNORM;
2274 table[MESA_FORMAT_R8G8B8A8_UNORM] = pack_row_ubyte_R8G8B8A8_UNORM;
2275 table[MESA_FORMAT_B8G8R8A8_UNORM] = pack_row_ubyte_B8G8R8A8_UNORM;
2276 table[MESA_FORMAT_A8R8G8B8_UNORM] = pack_row_ubyte_A8R8G8B8_UNORM;
2277 table[MESA_FORMAT_X8B8G8R8_UNORM] = pack_row_ubyte_A8B8G8R8_UNORM; /* reused */
2278 table[MESA_FORMAT_R8G8B8X8_UNORM] = pack_row_ubyte_R8G8B8A8_UNORM; /* reused */
2279 table[MESA_FORMAT_B8G8R8X8_UNORM] = pack_row_ubyte_B8G8R8X8_UNORM;
2280 table[MESA_FORMAT_X8R8G8B8_UNORM] = pack_row_ubyte_X8R8G8B8_UNORM;
2281 table[MESA_FORMAT_BGR_UNORM8] = pack_row_ubyte_BGR_UNORM8;
2282 table[MESA_FORMAT_RGB_UNORM8] = pack_row_ubyte_RGB_UNORM8;
2283 table[MESA_FORMAT_B5G6R5_UNORM] = pack_row_ubyte_B5G6R5_UNORM;
2284 table[MESA_FORMAT_R5G6B5_UNORM] = pack_row_ubyte_R5G6B5_UNORM;
2285
2286 initialized = GL_TRUE;
2287 }
2288
2289 return table[format];
2290 }
2291
2292
2293
2294 /**
2295 * Pack a row of GLfloat rgba[4] values to the destination.
2296 */
2297 void
2298 _mesa_pack_float_rgba_row(mesa_format format, GLuint n,
2299 const GLfloat src[][4], void *dst)
2300 {
2301 pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
2302 if (packrow) {
2303 /* use "fast" function */
2304 packrow(n, src, dst);
2305 }
2306 else {
2307 /* slower fallback */
2308 gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
2309 GLuint dstStride = _mesa_get_format_bytes(format);
2310 GLubyte *dstPtr = (GLubyte *) dst;
2311 GLuint i;
2312
2313 assert(pack);
2314 if (!pack)
2315 return;
2316
2317 for (i = 0; i < n; i++) {
2318 pack(src[i], dstPtr);
2319 dstPtr += dstStride;
2320 }
2321 }
2322 }
2323
2324
2325 /**
2326 * Pack a row of GLubyte rgba[4] values to the destination.
2327 */
2328 void
2329 _mesa_pack_ubyte_rgba_row(mesa_format format, GLuint n,
2330 const GLubyte src[][4], void *dst)
2331 {
2332 pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2333 if (packrow) {
2334 /* use "fast" function */
2335 packrow(n, src, dst);
2336 }
2337 else {
2338 /* slower fallback */
2339 gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
2340 const GLuint stride = _mesa_get_format_bytes(format);
2341 GLubyte *d = ((GLubyte *) dst);
2342 GLuint i;
2343
2344 assert(pack);
2345 if (!pack)
2346 return;
2347
2348 for (i = 0; i < n; i++) {
2349 pack(src[i], d);
2350 d += stride;
2351 }
2352 }
2353 }
2354
2355
2356 /**
2357 * Pack a 2D image of ubyte RGBA pixels in the given format.
2358 * \param srcRowStride source image row stride in bytes
2359 * \param dstRowStride destination image row stride in bytes
2360 */
2361 void
2362 _mesa_pack_ubyte_rgba_rect(mesa_format format, GLuint width, GLuint height,
2363 const GLubyte *src, GLint srcRowStride,
2364 void *dst, GLint dstRowStride)
2365 {
2366 pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
2367 GLubyte *dstUB = (GLubyte *) dst;
2368 GLuint i;
2369
2370 if (packrow) {
2371 if (srcRowStride == width * 4 * sizeof(GLubyte) &&
2372 dstRowStride == _mesa_format_row_stride(format, width)) {
2373 /* do whole image at once */
2374 packrow(width * height, (const GLubyte (*)[4]) src, dst);
2375 }
2376 else {
2377 /* row by row */
2378 for (i = 0; i < height; i++) {
2379 packrow(width, (const GLubyte (*)[4]) src, dstUB);
2380 src += srcRowStride;
2381 dstUB += dstRowStride;
2382 }
2383 }
2384 }
2385 else {
2386 /* slower fallback */
2387 for (i = 0; i < height; i++) {
2388 _mesa_pack_ubyte_rgba_row(format, width,
2389 (const GLubyte (*)[4]) src, dstUB);
2390 src += srcRowStride;
2391 dstUB += dstRowStride;
2392 }
2393 }
2394 }
2395
2396
2397
2398 /**
2399 ** Pack float Z pixels
2400 **/
2401
2402 static void
2403 pack_float_S8_UINT_Z24_UNORM(const GLfloat *src, void *dst)
2404 {
2405 /* don't disturb the stencil values */
2406 GLuint *d = ((GLuint *) dst);
2407 const GLdouble scale = (GLdouble) 0xffffff;
2408 GLuint s = *d & 0xff;
2409 GLuint z = (GLuint) (*src * scale);
2410 assert(z <= 0xffffff);
2411 *d = (z << 8) | s;
2412 }
2413
2414 static void
2415 pack_float_Z24_UNORM_S8_UINT(const GLfloat *src, void *dst)
2416 {
2417 /* don't disturb the stencil values */
2418 GLuint *d = ((GLuint *) dst);
2419 const GLdouble scale = (GLdouble) 0xffffff;
2420 GLuint s = *d & 0xff000000;
2421 GLuint z = (GLuint) (*src * scale);
2422 assert(z <= 0xffffff);
2423 *d = s | z;
2424 }
2425
2426 static void
2427 pack_float_Z_UNORM16(const GLfloat *src, void *dst)
2428 {
2429 GLushort *d = ((GLushort *) dst);
2430 const GLfloat scale = (GLfloat) 0xffff;
2431 *d = (GLushort) (*src * scale);
2432 }
2433
2434 static void
2435 pack_float_Z_UNORM32(const GLfloat *src, void *dst)
2436 {
2437 GLuint *d = ((GLuint *) dst);
2438 const GLdouble scale = (GLdouble) 0xffffffff;
2439 *d = (GLuint) (*src * scale);
2440 }
2441
2442 static void
2443 pack_float_Z_FLOAT32(const GLfloat *src, void *dst)
2444 {
2445 GLfloat *d = (GLfloat *) dst;
2446 *d = *src;
2447 }
2448
2449 gl_pack_float_z_func
2450 _mesa_get_pack_float_z_func(mesa_format format)
2451 {
2452 switch (format) {
2453 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2454 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2455 return pack_float_S8_UINT_Z24_UNORM;
2456 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2457 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2458 return pack_float_Z24_UNORM_S8_UINT;
2459 case MESA_FORMAT_Z_UNORM16:
2460 return pack_float_Z_UNORM16;
2461 case MESA_FORMAT_Z_UNORM32:
2462 return pack_float_Z_UNORM32;
2463 case MESA_FORMAT_Z_FLOAT32:
2464 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2465 return pack_float_Z_FLOAT32;
2466 default:
2467 _mesa_problem(NULL,
2468 "unexpected format in _mesa_get_pack_float_z_func()");
2469 return NULL;
2470 }
2471 }
2472
2473
2474
2475 /**
2476 ** Pack uint Z pixels. The incoming src value is always in
2477 ** the range [0, 2^32-1].
2478 **/
2479
2480 static void
2481 pack_uint_S8_UINT_Z24_UNORM(const GLuint *src, void *dst)
2482 {
2483 /* don't disturb the stencil values */
2484 GLuint *d = ((GLuint *) dst);
2485 GLuint s = *d & 0xff;
2486 GLuint z = *src & 0xffffff00;
2487 *d = z | s;
2488 }
2489
2490 static void
2491 pack_uint_Z24_UNORM_S8_UINT(const GLuint *src, void *dst)
2492 {
2493 /* don't disturb the stencil values */
2494 GLuint *d = ((GLuint *) dst);
2495 GLuint s = *d & 0xff000000;
2496 GLuint z = *src >> 8;
2497 *d = s | z;
2498 }
2499
2500 static void
2501 pack_uint_Z_UNORM16(const GLuint *src, void *dst)
2502 {
2503 GLushort *d = ((GLushort *) dst);
2504 *d = *src >> 16;
2505 }
2506
2507 static void
2508 pack_uint_Z_UNORM32(const GLuint *src, void *dst)
2509 {
2510 GLuint *d = ((GLuint *) dst);
2511 *d = *src;
2512 }
2513
2514 static void
2515 pack_uint_Z_FLOAT32(const GLuint *src, void *dst)
2516 {
2517 GLuint *d = ((GLuint *) dst);
2518 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2519 *d = (GLuint) (*src * scale);
2520 assert(*d >= 0.0f);
2521 assert(*d <= 1.0f);
2522 }
2523
2524 static void
2525 pack_uint_Z_FLOAT32_X24S8(const GLuint *src, void *dst)
2526 {
2527 GLfloat *d = ((GLfloat *) dst);
2528 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2529 *d = (GLfloat) (*src * scale);
2530 assert(*d >= 0.0f);
2531 assert(*d <= 1.0f);
2532 }
2533
2534 gl_pack_uint_z_func
2535 _mesa_get_pack_uint_z_func(mesa_format format)
2536 {
2537 switch (format) {
2538 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2539 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2540 return pack_uint_S8_UINT_Z24_UNORM;
2541 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2542 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2543 return pack_uint_Z24_UNORM_S8_UINT;
2544 case MESA_FORMAT_Z_UNORM16:
2545 return pack_uint_Z_UNORM16;
2546 case MESA_FORMAT_Z_UNORM32:
2547 return pack_uint_Z_UNORM32;
2548 case MESA_FORMAT_Z_FLOAT32:
2549 return pack_uint_Z_FLOAT32;
2550 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2551 return pack_uint_Z_FLOAT32_X24S8;
2552 default:
2553 _mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
2554 return NULL;
2555 }
2556 }
2557
2558
2559 /**
2560 ** Pack ubyte stencil pixels
2561 **/
2562
2563 static void
2564 pack_ubyte_stencil_Z24_S8(const GLubyte *src, void *dst)
2565 {
2566 /* don't disturb the Z values */
2567 GLuint *d = ((GLuint *) dst);
2568 GLuint s = *src;
2569 GLuint z = *d & 0xffffff00;
2570 *d = z | s;
2571 }
2572
2573 static void
2574 pack_ubyte_stencil_S8_Z24(const GLubyte *src, void *dst)
2575 {
2576 /* don't disturb the Z values */
2577 GLuint *d = ((GLuint *) dst);
2578 GLuint s = *src << 24;
2579 GLuint z = *d & 0xffffff;
2580 *d = s | z;
2581 }
2582
2583 static void
2584 pack_ubyte_stencil_S8(const GLubyte *src, void *dst)
2585 {
2586 GLubyte *d = (GLubyte *) dst;
2587 *d = *src;
2588 }
2589
2590 static void
2591 pack_ubyte_stencil_Z32_FLOAT_X24S8(const GLubyte *src, void *dst)
2592 {
2593 GLfloat *d = ((GLfloat *) dst);
2594 d[1] = *src;
2595 }
2596
2597
2598 gl_pack_ubyte_stencil_func
2599 _mesa_get_pack_ubyte_stencil_func(mesa_format format)
2600 {
2601 switch (format) {
2602 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2603 return pack_ubyte_stencil_Z24_S8;
2604 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2605 return pack_ubyte_stencil_S8_Z24;
2606 case MESA_FORMAT_S_UINT8:
2607 return pack_ubyte_stencil_S8;
2608 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2609 return pack_ubyte_stencil_Z32_FLOAT_X24S8;
2610 default:
2611 _mesa_problem(NULL,
2612 "unexpected format in _mesa_pack_ubyte_stencil_func()");
2613 return NULL;
2614 }
2615 }
2616
2617
2618
2619 void
2620 _mesa_pack_float_z_row(mesa_format format, GLuint n,
2621 const GLfloat *src, void *dst)
2622 {
2623 switch (format) {
2624 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2625 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2626 {
2627 /* don't disturb the stencil values */
2628 GLuint *d = ((GLuint *) dst);
2629 const GLdouble scale = (GLdouble) 0xffffff;
2630 GLuint i;
2631 for (i = 0; i < n; i++) {
2632 GLuint s = d[i] & 0xff;
2633 GLuint z = (GLuint) (src[i] * scale);
2634 assert(z <= 0xffffff);
2635 d[i] = (z << 8) | s;
2636 }
2637 }
2638 break;
2639 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2640 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2641 {
2642 /* don't disturb the stencil values */
2643 GLuint *d = ((GLuint *) dst);
2644 const GLdouble scale = (GLdouble) 0xffffff;
2645 GLuint i;
2646 for (i = 0; i < n; i++) {
2647 GLuint s = d[i] & 0xff000000;
2648 GLuint z = (GLuint) (src[i] * scale);
2649 assert(z <= 0xffffff);
2650 d[i] = s | z;
2651 }
2652 }
2653 break;
2654 case MESA_FORMAT_Z_UNORM16:
2655 {
2656 GLushort *d = ((GLushort *) dst);
2657 const GLfloat scale = (GLfloat) 0xffff;
2658 GLuint i;
2659 for (i = 0; i < n; i++) {
2660 d[i] = (GLushort) (src[i] * scale);
2661 }
2662 }
2663 break;
2664 case MESA_FORMAT_Z_UNORM32:
2665 {
2666 GLuint *d = ((GLuint *) dst);
2667 const GLdouble scale = (GLdouble) 0xffffffff;
2668 GLuint i;
2669 for (i = 0; i < n; i++) {
2670 d[i] = (GLuint) (src[i] * scale);
2671 }
2672 }
2673 break;
2674 case MESA_FORMAT_Z_FLOAT32:
2675 memcpy(dst, src, n * sizeof(GLfloat));
2676 break;
2677 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2678 {
2679 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2680 GLuint i;
2681 for (i = 0; i < n; i++) {
2682 d[i].z = src[i];
2683 }
2684 }
2685 break;
2686 default:
2687 _mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
2688 }
2689 }
2690
2691
2692 /**
2693 * The incoming Z values are always in the range [0, 0xffffffff].
2694 */
2695 void
2696 _mesa_pack_uint_z_row(mesa_format format, GLuint n,
2697 const GLuint *src, void *dst)
2698 {
2699 switch (format) {
2700 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2701 case MESA_FORMAT_X8_UINT_Z24_UNORM:
2702 {
2703 /* don't disturb the stencil values */
2704 GLuint *d = ((GLuint *) dst);
2705 GLuint i;
2706 for (i = 0; i < n; i++) {
2707 GLuint s = d[i] & 0xff;
2708 GLuint z = src[i] & 0xffffff00;
2709 d[i] = z | s;
2710 }
2711 }
2712 break;
2713 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2714 case MESA_FORMAT_Z24_UNORM_X8_UINT:
2715 {
2716 /* don't disturb the stencil values */
2717 GLuint *d = ((GLuint *) dst);
2718 GLuint i;
2719 for (i = 0; i < n; i++) {
2720 GLuint s = d[i] & 0xff000000;
2721 GLuint z = src[i] >> 8;
2722 d[i] = s | z;
2723 }
2724 }
2725 break;
2726 case MESA_FORMAT_Z_UNORM16:
2727 {
2728 GLushort *d = ((GLushort *) dst);
2729 GLuint i;
2730 for (i = 0; i < n; i++) {
2731 d[i] = src[i] >> 16;
2732 }
2733 }
2734 break;
2735 case MESA_FORMAT_Z_UNORM32:
2736 memcpy(dst, src, n * sizeof(GLfloat));
2737 break;
2738 case MESA_FORMAT_Z_FLOAT32:
2739 {
2740 GLuint *d = ((GLuint *) dst);
2741 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2742 GLuint i;
2743 for (i = 0; i < n; i++) {
2744 d[i] = (GLuint) (src[i] * scale);
2745 assert(d[i] >= 0.0f);
2746 assert(d[i] <= 1.0f);
2747 }
2748 }
2749 break;
2750 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2751 {
2752 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2753 const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
2754 GLuint i;
2755 for (i = 0; i < n; i++) {
2756 d[i].z = (GLfloat) (src[i] * scale);
2757 assert(d[i].z >= 0.0f);
2758 assert(d[i].z <= 1.0f);
2759 }
2760 }
2761 break;
2762 default:
2763 _mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
2764 }
2765 }
2766
2767
2768 void
2769 _mesa_pack_ubyte_stencil_row(mesa_format format, GLuint n,
2770 const GLubyte *src, void *dst)
2771 {
2772 switch (format) {
2773 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2774 {
2775 /* don't disturb the Z values */
2776 GLuint *d = ((GLuint *) dst);
2777 GLuint i;
2778 for (i = 0; i < n; i++) {
2779 GLuint s = src[i];
2780 GLuint z = d[i] & 0xffffff00;
2781 d[i] = z | s;
2782 }
2783 }
2784 break;
2785 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2786 {
2787 /* don't disturb the Z values */
2788 GLuint *d = ((GLuint *) dst);
2789 GLuint i;
2790 for (i = 0; i < n; i++) {
2791 GLuint s = src[i] << 24;
2792 GLuint z = d[i] & 0xffffff;
2793 d[i] = s | z;
2794 }
2795 }
2796 break;
2797 case MESA_FORMAT_S_UINT8:
2798 memcpy(dst, src, n * sizeof(GLubyte));
2799 break;
2800 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2801 {
2802 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2803 GLuint i;
2804 for (i = 0; i < n; i++) {
2805 d[i].x24s8 = src[i];
2806 }
2807 }
2808 break;
2809 default:
2810 _mesa_problem(NULL, "unexpected format in _mesa_pack_ubyte_stencil_row()");
2811 }
2812 }
2813
2814
2815 /**
2816 * Incoming Z/stencil values are always in uint_24_8 format.
2817 */
2818 void
2819 _mesa_pack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
2820 const GLuint *src, void *dst)
2821 {
2822 switch (format) {
2823 case MESA_FORMAT_S8_UINT_Z24_UNORM:
2824 memcpy(dst, src, n * sizeof(GLuint));
2825 break;
2826 case MESA_FORMAT_Z24_UNORM_S8_UINT:
2827 {
2828 GLuint *d = ((GLuint *) dst);
2829 GLuint i;
2830 for (i = 0; i < n; i++) {
2831 GLuint s = src[i] << 24;
2832 GLuint z = src[i] >> 8;
2833 d[i] = s | z;
2834 }
2835 }
2836 break;
2837 case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
2838 {
2839 const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
2840 struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
2841 GLuint i;
2842 for (i = 0; i < n; i++) {
2843 GLfloat z = (GLfloat) ((src[i] >> 8) * scale);
2844 d[i].z = z;
2845 d[i].x24s8 = src[i];
2846 }
2847 }
2848 break;
2849 default:
2850 _mesa_problem(NULL, "bad format %s in _mesa_pack_ubyte_s_row",
2851 _mesa_get_format_name(format));
2852 return;
2853 }
2854 }
2855
2856
2857
2858 /**
2859 * Convert a boolean color mask to a packed color where each channel of
2860 * the packed value at dst will be 0 or ~0 depending on the colorMask.
2861 */
2862 void
2863 _mesa_pack_colormask(mesa_format format, const GLubyte colorMask[4], void *dst)
2864 {
2865 GLfloat maskColor[4];
2866
2867 switch (_mesa_get_format_datatype(format)) {
2868 case GL_UNSIGNED_NORMALIZED:
2869 /* simple: 1.0 will convert to ~0 in the right bit positions */
2870 maskColor[0] = colorMask[0] ? 1.0f : 0.0f;
2871 maskColor[1] = colorMask[1] ? 1.0f : 0.0f;
2872 maskColor[2] = colorMask[2] ? 1.0f : 0.0f;
2873 maskColor[3] = colorMask[3] ? 1.0f : 0.0f;
2874 _mesa_pack_float_rgba_row(format, 1,
2875 (const GLfloat (*)[4]) maskColor, dst);
2876 break;
2877 case GL_SIGNED_NORMALIZED:
2878 case GL_FLOAT:
2879 /* These formats are harder because it's hard to know the floating
2880 * point values that will convert to ~0 for each color channel's bits.
2881 * This solution just generates a non-zero value for each color channel
2882 * then fixes up the non-zero values to be ~0.
2883 * Note: we'll need to add special case code if we ever have to deal
2884 * with formats with unequal color channel sizes, like R11_G11_B10.
2885 * We issue a warning below for channel sizes other than 8,16,32.
2886 */
2887 {
2888 GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
2889 GLuint bytes = _mesa_get_format_bytes(format);
2890 GLuint i;
2891
2892 /* this should put non-zero values into the channels of dst */
2893 maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
2894 maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
2895 maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
2896 maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
2897 _mesa_pack_float_rgba_row(format, 1,
2898 (const GLfloat (*)[4]) maskColor, dst);
2899
2900 /* fix-up the dst channels by converting non-zero values to ~0 */
2901 if (bits == 8) {
2902 GLubyte *d = (GLubyte *) dst;
2903 for (i = 0; i < bytes; i++) {
2904 d[i] = d[i] ? 0xff : 0x0;
2905 }
2906 }
2907 else if (bits == 16) {
2908 GLushort *d = (GLushort *) dst;
2909 for (i = 0; i < bytes / 2; i++) {
2910 d[i] = d[i] ? 0xffff : 0x0;
2911 }
2912 }
2913 else if (bits == 32) {
2914 GLuint *d = (GLuint *) dst;
2915 for (i = 0; i < bytes / 4; i++) {
2916 d[i] = d[i] ? 0xffffffffU : 0x0;
2917 }
2918 }
2919 else {
2920 _mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
2921 return;
2922 }
2923 }
2924 break;
2925 default:
2926 _mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
2927 return;
2928 }
2929 }