Get Gentoo!
gentoo.org sites
gentoo.org Wiki Bugs Forums Packages
Planet Archives Sources
Infra Status

Gentoo Archives: gentoo-commits

From: "Matt Turner (mattst88)" <mattst88@g.o>
To: gentoo-commits@l.g.o
Subject: [gentoo-commits] gentoo-x86 commit in media-libs/mesa/files: mesa-10.3.7-format_utils.c.patch
Date: Sun, 01 Mar 2015 19:35:22
Message-Id: 20150301193516.98B7712D3A@oystercatcher.gentoo.org
1 mattst88 15/03/01 19:35:16
2
3 Added: mesa-10.3.7-format_utils.c.patch
4 Log:
5 Add patch to reduce compile time/memory, bug 540960.
6
7 (Portage version: 2.2.17/cvs/Linux x86_64, signed Manifest commit with key 974CA72A)
8
9 Revision Changes Path
10 1.1 media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch
11
12 file : http://sources.gentoo.org/viewvc.cgi/gentoo-x86/media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch?rev=1.1&view=markup
13 plain: http://sources.gentoo.org/viewvc.cgi/gentoo-x86/media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch?rev=1.1&content-type=text/plain
14
15 Index: mesa-10.3.7-format_utils.c.patch
16 ===================================================================
17 From cfeb394224f2daeb2139cf4ec489a4dd8297a44d Mon Sep 17 00:00:00 2001
18 From: Brian Paul <brianp@××××××.com>
19 Date: Fri, 12 Sep 2014 08:31:15 -0600
20 Subject: [PATCH] mesa: break up _mesa_swizzle_and_convert() to reduce compile
21 time
22
23 This reduces gcc -O3 compile time to 1/4 of what it was on my system.
24 Reduces MSVC release build time too.
25
26 Reviewed-by: Jason Ekstrand <jason.ekstrand@×××××.com>
27 ---
28 src/mesa/main/format_utils.c | 1030 ++++++++++++++++++++++--------------------
29 1 file changed, 550 insertions(+), 480 deletions(-)
30
31 diff --git a/src/mesa/main/format_utils.c b/src/mesa/main/format_utils.c
32 index 240e3bc..29d779a 100644
33 --- a/src/mesa/main/format_utils.c
34 +++ b/src/mesa/main/format_utils.c
35 @@ -352,9 +352,14 @@ swizzle_convert_try_memcpy(void *dst, GLenum dst_type, int num_dst_channels,
36 */
37 #define SWIZZLE_CONVERT(DST_TYPE, SRC_TYPE, CONV) \
38 do { \
39 + const uint8_t swizzle_x = swizzle[0]; \
40 + const uint8_t swizzle_y = swizzle[1]; \
41 + const uint8_t swizzle_z = swizzle[2]; \
42 + const uint8_t swizzle_w = swizzle[3]; \
43 const SRC_TYPE *typed_src = void_src; \
44 DST_TYPE *typed_dst = void_dst; \
45 DST_TYPE tmp[7]; \
46 + int s, j; \
47 tmp[4] = 0; \
48 tmp[5] = one; \
49 switch (num_dst_channels) { \
50 @@ -423,7 +428,527 @@ swizzle_convert_try_memcpy(void *dst, GLenum dst_type, int num_dst_channels,
51 } \
52 break; \
53 } \
54 - } while (0);
55 + } while (0)
56 +
57 +
58 +static void
59 +convert_float(void *void_dst, int num_dst_channels,
60 + const void *void_src, GLenum src_type, int num_src_channels,
61 + const uint8_t swizzle[4], bool normalized, int count)
62 +{
63 + const float one = 1.0f;
64 +
65 + switch (src_type) {
66 + case GL_FLOAT:
67 + SWIZZLE_CONVERT(float, float, src);
68 + break;
69 + case GL_HALF_FLOAT:
70 + SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src));
71 + break;
72 + case GL_UNSIGNED_BYTE:
73 + if (normalized) {
74 + SWIZZLE_CONVERT(float, uint8_t, unorm_to_float(src, 8));
75 + } else {
76 + SWIZZLE_CONVERT(float, uint8_t, src);
77 + }
78 + break;
79 + case GL_BYTE:
80 + if (normalized) {
81 + SWIZZLE_CONVERT(float, int8_t, snorm_to_float(src, 8));
82 + } else {
83 + SWIZZLE_CONVERT(float, int8_t, src);
84 + }
85 + break;
86 + case GL_UNSIGNED_SHORT:
87 + if (normalized) {
88 + SWIZZLE_CONVERT(float, uint16_t, unorm_to_float(src, 16));
89 + } else {
90 + SWIZZLE_CONVERT(float, uint16_t, src);
91 + }
92 + break;
93 + case GL_SHORT:
94 + if (normalized) {
95 + SWIZZLE_CONVERT(float, int16_t, snorm_to_float(src, 16));
96 + } else {
97 + SWIZZLE_CONVERT(float, int16_t, src);
98 + }
99 + break;
100 + case GL_UNSIGNED_INT:
101 + if (normalized) {
102 + SWIZZLE_CONVERT(float, uint32_t, unorm_to_float(src, 32));
103 + } else {
104 + SWIZZLE_CONVERT(float, uint32_t, src);
105 + }
106 + break;
107 + case GL_INT:
108 + if (normalized) {
109 + SWIZZLE_CONVERT(float, int32_t, snorm_to_float(src, 32));
110 + } else {
111 + SWIZZLE_CONVERT(float, int32_t, src);
112 + }
113 + break;
114 + default:
115 + assert(!"Invalid channel type combination");
116 + }
117 +}
118 +
119 +
120 +static void
121 +convert_half_float(void *void_dst, int num_dst_channels,
122 + const void *void_src, GLenum src_type, int num_src_channels,
123 + const uint8_t swizzle[4], bool normalized, int count)
124 +{
125 + const uint16_t one = _mesa_float_to_half(1.0f);
126 +
127 + switch (src_type) {
128 + case GL_FLOAT:
129 + SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src));
130 + break;
131 + case GL_HALF_FLOAT:
132 + SWIZZLE_CONVERT(uint16_t, uint16_t, src);
133 + break;
134 + case GL_UNSIGNED_BYTE:
135 + if (normalized) {
136 + SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_half(src, 8));
137 + } else {
138 + SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src));
139 + }
140 + break;
141 + case GL_BYTE:
142 + if (normalized) {
143 + SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_half(src, 8));
144 + } else {
145 + SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src));
146 + }
147 + break;
148 + case GL_UNSIGNED_SHORT:
149 + if (normalized) {
150 + SWIZZLE_CONVERT(uint16_t, uint16_t, unorm_to_half(src, 16));
151 + } else {
152 + SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src));
153 + }
154 + break;
155 + case GL_SHORT:
156 + if (normalized) {
157 + SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_half(src, 16));
158 + } else {
159 + SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src));
160 + }
161 + break;
162 + case GL_UNSIGNED_INT:
163 + if (normalized) {
164 + SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_half(src, 32));
165 + } else {
166 + SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src));
167 + }
168 + break;
169 + case GL_INT:
170 + if (normalized) {
171 + SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_half(src, 32));
172 + } else {
173 + SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_float_to_half(src));
174 + }
175 + break;
176 + default:
177 + assert(!"Invalid channel type combination");
178 + }
179 +}
180 +
181 +
182 +static void
183 +convert_ubyte(void *void_dst, int num_dst_channels,
184 + const void *void_src, GLenum src_type, int num_src_channels,
185 + const uint8_t swizzle[4], bool normalized, int count)
186 +{
187 + const uint8_t one = normalized ? UINT8_MAX : 1;
188 +
189 + switch (src_type) {
190 + case GL_FLOAT:
191 + if (normalized) {
192 + SWIZZLE_CONVERT(uint8_t, float, float_to_unorm(src, 8));
193 + } else {
194 + SWIZZLE_CONVERT(uint8_t, float, (src < 0) ? 0 : src);
195 + }
196 + break;
197 + case GL_HALF_FLOAT:
198 + if (normalized) {
199 + SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_unorm(src, 8));
200 + } else {
201 + SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_uint(src));
202 + }
203 + break;
204 + case GL_UNSIGNED_BYTE:
205 + SWIZZLE_CONVERT(uint8_t, uint8_t, src);
206 + break;
207 + case GL_BYTE:
208 + if (normalized) {
209 + SWIZZLE_CONVERT(uint8_t, int8_t, snorm_to_unorm(src, 8, 8));
210 + } else {
211 + SWIZZLE_CONVERT(uint8_t, int8_t, (src < 0) ? 0 : src);
212 + }
213 + break;
214 + case GL_UNSIGNED_SHORT:
215 + if (normalized) {
216 + SWIZZLE_CONVERT(uint8_t, uint16_t, unorm_to_unorm(src, 16, 8));
217 + } else {
218 + SWIZZLE_CONVERT(uint8_t, uint16_t, src);
219 + }
220 + break;
221 + case GL_SHORT:
222 + if (normalized) {
223 + SWIZZLE_CONVERT(uint8_t, int16_t, snorm_to_unorm(src, 16, 8));
224 + } else {
225 + SWIZZLE_CONVERT(uint8_t, int16_t, (src < 0) ? 0 : src);
226 + }
227 + break;
228 + case GL_UNSIGNED_INT:
229 + if (normalized) {
230 + SWIZZLE_CONVERT(uint8_t, uint32_t, unorm_to_unorm(src, 32, 8));
231 + } else {
232 + SWIZZLE_CONVERT(uint8_t, uint32_t, src);
233 + }
234 + break;
235 + case GL_INT:
236 + if (normalized) {
237 + SWIZZLE_CONVERT(uint8_t, int32_t, snorm_to_unorm(src, 32, 8));
238 + } else {
239 + SWIZZLE_CONVERT(uint8_t, int32_t, (src < 0) ? 0 : src);
240 + }
241 + break;
242 + default:
243 + assert(!"Invalid channel type combination");
244 + }
245 +}
246 +
247 +
248 +static void
249 +convert_byte(void *void_dst, int num_dst_channels,
250 + const void *void_src, GLenum src_type, int num_src_channels,
251 + const uint8_t swizzle[4], bool normalized, int count)
252 +{
253 + const int8_t one = normalized ? INT8_MAX : 1;
254 +
255 + switch (src_type) {
256 + case GL_FLOAT:
257 + if (normalized) {
258 + SWIZZLE_CONVERT(uint8_t, float, float_to_snorm(src, 8));
259 + } else {
260 + SWIZZLE_CONVERT(uint8_t, float, src);
261 + }
262 + break;
263 + case GL_HALF_FLOAT:
264 + if (normalized) {
265 + SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_snorm(src, 8));
266 + } else {
267 + SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_float(src));
268 + }
269 + break;
270 + case GL_UNSIGNED_BYTE:
271 + if (normalized) {
272 + SWIZZLE_CONVERT(int8_t, uint8_t, unorm_to_snorm(src, 8, 8));
273 + } else {
274 + SWIZZLE_CONVERT(int8_t, uint8_t, src);
275 + }
276 + break;
277 + case GL_BYTE:
278 + SWIZZLE_CONVERT(int8_t, int8_t, src);
279 + break;
280 + case GL_UNSIGNED_SHORT:
281 + if (normalized) {
282 + SWIZZLE_CONVERT(int8_t, uint16_t, unorm_to_snorm(src, 16, 8));
283 + } else {
284 + SWIZZLE_CONVERT(int8_t, uint16_t, src);
285 + }
286 + break;
287 + case GL_SHORT:
288 + if (normalized) {
289 + SWIZZLE_CONVERT(int8_t, int16_t, snorm_to_snorm(src, 16, 8));
290 + } else {
291 + SWIZZLE_CONVERT(int8_t, int16_t, src);
292 + }
293 + break;
294 + case GL_UNSIGNED_INT:
295 + if (normalized) {
296 + SWIZZLE_CONVERT(int8_t, uint32_t, unorm_to_snorm(src, 32, 8));
297 + } else {
298 + SWIZZLE_CONVERT(int8_t, uint32_t, src);
299 + }
300 + break;
301 + case GL_INT:
302 + if (normalized) {
303 + SWIZZLE_CONVERT(int8_t, int32_t, snorm_to_snorm(src, 32, 8));
304 + } else {
305 + SWIZZLE_CONVERT(int8_t, int32_t, src);
306 + }
307 + break;
308 + default:
309 + assert(!"Invalid channel type combination");
310 + }
311 +}
312 +
313 +
314 +static void
315 +convert_ushort(void *void_dst, int num_dst_channels,
316 + const void *void_src, GLenum src_type, int num_src_channels,
317 + const uint8_t swizzle[4], bool normalized, int count)
318 +{
319 + const uint16_t one = normalized ? UINT16_MAX : 1;
320 +
321 + switch (src_type) {
322 + case GL_FLOAT:
323 + if (normalized) {
324 + SWIZZLE_CONVERT(uint16_t, float, float_to_unorm(src, 16));
325 + } else {
326 + SWIZZLE_CONVERT(uint16_t, float, (src < 0) ? 0 : src);
327 + }
328 + break;
329 + case GL_HALF_FLOAT:
330 + if (normalized) {
331 + SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_unorm(src, 16));
332 + } else {
333 + SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_uint(src));
334 + }
335 + break;
336 + case GL_UNSIGNED_BYTE:
337 + if (normalized) {
338 + SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_unorm(src, 8, 16));
339 + } else {
340 + SWIZZLE_CONVERT(uint16_t, uint8_t, src);
341 + }
342 + break;
343 + case GL_BYTE:
344 + if (normalized) {
345 + SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_unorm(src, 8, 16));
346 + } else {
347 + SWIZZLE_CONVERT(uint16_t, int8_t, (src < 0) ? 0 : src);
348 + }
349 + break;
350 + case GL_UNSIGNED_SHORT:
351 + SWIZZLE_CONVERT(uint16_t, uint16_t, src);
352 + break;
353 + case GL_SHORT:
354 + if (normalized) {
355 + SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_unorm(src, 16, 16));
356 + } else {
357 + SWIZZLE_CONVERT(uint16_t, int16_t, (src < 0) ? 0 : src);
358 + }
359 + break;
360 + case GL_UNSIGNED_INT:
361 + if (normalized) {
362 + SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_unorm(src, 32, 16));
363 + } else {
364 + SWIZZLE_CONVERT(uint16_t, uint32_t, src);
365 + }
366 + break;
367 + case GL_INT:
368 + if (normalized) {
369 + SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_unorm(src, 32, 16));
370 + } else {
371 + SWIZZLE_CONVERT(uint16_t, int32_t, (src < 0) ? 0 : src);
372 + }
373 + break;
374 + default:
375 + assert(!"Invalid channel type combination");
376 + }
377 +}
378 +
379 +
380 +static void
381 +convert_short(void *void_dst, int num_dst_channels,
382 + const void *void_src, GLenum src_type, int num_src_channels,
383 + const uint8_t swizzle[4], bool normalized, int count)
384 +{
385 + const int16_t one = normalized ? INT16_MAX : 1;
386 +
387 + switch (src_type) {
388 + case GL_FLOAT:
389 + if (normalized) {
390 + SWIZZLE_CONVERT(uint16_t, float, float_to_snorm(src, 16));
391 + } else {
392 + SWIZZLE_CONVERT(uint16_t, float, src);
393 + }
394 + break;
395 + case GL_HALF_FLOAT:
396 + if (normalized) {
397 + SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_snorm(src, 16));
398 + } else {
399 + SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_float(src));
400 + }
401 + break;
402 + case GL_UNSIGNED_BYTE:
403 + if (normalized) {
404 + SWIZZLE_CONVERT(int16_t, uint8_t, unorm_to_snorm(src, 8, 16));
405 + } else {
406 + SWIZZLE_CONVERT(int16_t, uint8_t, src);
407 + }
408 + break;
409 + case GL_BYTE:
410 + if (normalized) {
411 + SWIZZLE_CONVERT(int16_t, int8_t, snorm_to_snorm(src, 8, 16));
412 + } else {
413 + SWIZZLE_CONVERT(int16_t, int8_t, src);
414 + }
415 + break;
416 + case GL_UNSIGNED_SHORT:
417 + if (normalized) {
418 + SWIZZLE_CONVERT(int16_t, uint16_t, unorm_to_snorm(src, 16, 16));
419 + } else {
420 + SWIZZLE_CONVERT(int16_t, uint16_t, src);
421 + }
422 + break;
423 + case GL_SHORT:
424 + SWIZZLE_CONVERT(int16_t, int16_t, src);
425 + break;
426 + case GL_UNSIGNED_INT:
427 + if (normalized) {
428 + SWIZZLE_CONVERT(int16_t, uint32_t, unorm_to_snorm(src, 32, 16));
429 + } else {
430 + SWIZZLE_CONVERT(int16_t, uint32_t, src);
431 + }
432 + break;
433 + case GL_INT:
434 + if (normalized) {
435 + SWIZZLE_CONVERT(int16_t, int32_t, snorm_to_snorm(src, 32, 16));
436 + } else {
437 + SWIZZLE_CONVERT(int16_t, int32_t, src);
438 + }
439 + break;
440 + default:
441 + assert(!"Invalid channel type combination");
442 + }
443 +}
444 +
445 +static void
446 +convert_uint(void *void_dst, int num_dst_channels,
447 + const void *void_src, GLenum src_type, int num_src_channels,
448 + const uint8_t swizzle[4], bool normalized, int count)
449 +{
450 + const uint32_t one = normalized ? UINT32_MAX : 1;
451 +
452 + switch (src_type) {
453 + case GL_FLOAT:
454 + if (normalized) {
455 + SWIZZLE_CONVERT(uint32_t, float, float_to_unorm(src, 32));
456 + } else {
457 + SWIZZLE_CONVERT(uint32_t, float, (src < 0) ? 0 : src);
458 + }
459 + break;
460 + case GL_HALF_FLOAT:
461 + if (normalized) {
462 + SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_unorm(src, 32));
463 + } else {
464 + SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_uint(src));
465 + }
466 + break;
467 + case GL_UNSIGNED_BYTE:
468 + if (normalized) {
469 + SWIZZLE_CONVERT(uint32_t, uint8_t, unorm_to_unorm(src, 8, 32));
470 + } else {
471 + SWIZZLE_CONVERT(uint32_t, uint8_t, src);
472 + }
473 + break;
474 + case GL_BYTE:
475 + if (normalized) {
476 + SWIZZLE_CONVERT(uint32_t, int8_t, snorm_to_unorm(src, 8, 32));
477 + } else {
478 + SWIZZLE_CONVERT(uint32_t, int8_t, (src < 0) ? 0 : src);
479 + }
480 + break;
481 + case GL_UNSIGNED_SHORT:
482 + if (normalized) {
483 + SWIZZLE_CONVERT(uint32_t, uint16_t, unorm_to_unorm(src, 16, 32));
484 + } else {
485 + SWIZZLE_CONVERT(uint32_t, uint16_t, src);
486 + }
487 + break;
488 + case GL_SHORT:
489 + if (normalized) {
490 + SWIZZLE_CONVERT(uint32_t, int16_t, snorm_to_unorm(src, 16, 32));
491 + } else {
492 + SWIZZLE_CONVERT(uint32_t, int16_t, (src < 0) ? 0 : src);
493 + }
494 + break;
495 + case GL_UNSIGNED_INT:
496 + SWIZZLE_CONVERT(uint32_t, uint32_t, src);
497 + break;
498 + case GL_INT:
499 + if (normalized) {
500 + SWIZZLE_CONVERT(uint32_t, int32_t, snorm_to_unorm(src, 32, 32));
501 + } else {
502 + SWIZZLE_CONVERT(uint32_t, int32_t, (src < 0) ? 0 : src);
503 + }
504 + break;
505 + default:
506 + assert(!"Invalid channel type combination");
507 + }
508 +}
509 +
510 +
511 +static void
512 +convert_int(void *void_dst, int num_dst_channels,
513 + const void *void_src, GLenum src_type, int num_src_channels,
514 + const uint8_t swizzle[4], bool normalized, int count)
515 +{
516 + const int32_t one = normalized ? INT32_MAX : 12;
517 +
518 + switch (src_type) {
519 + case GL_FLOAT:
520 + if (normalized) {
521 + SWIZZLE_CONVERT(uint32_t, float, float_to_snorm(src, 32));
522 + } else {
523 + SWIZZLE_CONVERT(uint32_t, float, src);
524 + }
525 + break;
526 + case GL_HALF_FLOAT:
527 + if (normalized) {
528 + SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_snorm(src, 32));
529 + } else {
530 + SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_float(src));
531 + }
532 + break;
533 + case GL_UNSIGNED_BYTE:
534 + if (normalized) {
535 + SWIZZLE_CONVERT(int32_t, uint8_t, unorm_to_snorm(src, 8, 32));
536 + } else {
537 + SWIZZLE_CONVERT(int32_t, uint8_t, src);
538 + }
539 + break;
540 + case GL_BYTE:
541 + if (normalized) {
542 + SWIZZLE_CONVERT(int32_t, int8_t, snorm_to_snorm(src, 8, 32));
543 + } else {
544 + SWIZZLE_CONVERT(int32_t, int8_t, src);
545 + }
546 + break;
547 + case GL_UNSIGNED_SHORT:
548 + if (normalized) {
549 + SWIZZLE_CONVERT(int32_t, uint16_t, unorm_to_snorm(src, 16, 32));
550 + } else {
551 + SWIZZLE_CONVERT(int32_t, uint16_t, src);
552 + }
553 + break;
554 + case GL_SHORT:
555 + if (normalized) {
556 + SWIZZLE_CONVERT(int32_t, int16_t, snorm_to_snorm(src, 16, 32));
557 + } else {
558 + SWIZZLE_CONVERT(int32_t, int16_t, src);
559 + }
560 + break;
561 + case GL_UNSIGNED_INT:
562 + if (normalized) {
563 + SWIZZLE_CONVERT(int32_t, uint32_t, unorm_to_snorm(src, 32, 32));
564 + } else {
565 + SWIZZLE_CONVERT(int32_t, uint32_t, src);
566 + }
567 + break;
568 + case GL_INT:
569 + SWIZZLE_CONVERT(int32_t, int32_t, src);
570 + break;
571 + default:
572 + assert(!"Invalid channel type combination");
573 + }
574 +}
575 +
576
577 /**
578 * Convert between array-based color formats.
579 @@ -478,499 +1003,44 @@ _mesa_swizzle_and_convert(void *void_dst, GLenum dst_type, int num_dst_channels,
580 const void *void_src, GLenum src_type, int num_src_channels,
581 const uint8_t swizzle[4], bool normalized, int count)
582 {
583 - int s, j;
584 - register uint8_t swizzle_x, swizzle_y, swizzle_z, swizzle_w;
585 -
586 if (swizzle_convert_try_memcpy(void_dst, dst_type, num_dst_channels,
587 void_src, src_type, num_src_channels,
588 swizzle, normalized, count))
589 return;
590
591 - swizzle_x = swizzle[0];
592 - swizzle_y = swizzle[1];
593 - swizzle_z = swizzle[2];
594 - swizzle_w = swizzle[3];
595 -
596 switch (dst_type) {
597 case GL_FLOAT:
598 - {
599 - const float one = 1.0f;
600 - switch (src_type) {
601 - case GL_FLOAT:
602 - SWIZZLE_CONVERT(float, float, src)
603 - break;
604 - case GL_HALF_FLOAT:
605 - SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src))
606 - break;
607 - case GL_UNSIGNED_BYTE:
608 - if (normalized) {
609 - SWIZZLE_CONVERT(float, uint8_t, unorm_to_float(src, 8))
610 - } else {
611 - SWIZZLE_CONVERT(float, uint8_t, src)
612 - }
613 - break;
614 - case GL_BYTE:
615 - if (normalized) {
616 - SWIZZLE_CONVERT(float, int8_t, snorm_to_float(src, 8))
617 - } else {
618 - SWIZZLE_CONVERT(float, int8_t, src)
619 - }
620 - break;
621 - case GL_UNSIGNED_SHORT:
622 - if (normalized) {
623 - SWIZZLE_CONVERT(float, uint16_t, unorm_to_float(src, 16))
624 - } else {
625 - SWIZZLE_CONVERT(float, uint16_t, src)
626 - }
627 - break;
628 - case GL_SHORT:
629 - if (normalized) {
630 - SWIZZLE_CONVERT(float, int16_t, snorm_to_float(src, 16))
631 - } else {
632 - SWIZZLE_CONVERT(float, int16_t, src)
633 - }
634 - break;
635 - case GL_UNSIGNED_INT:
636 - if (normalized) {
637 - SWIZZLE_CONVERT(float, uint32_t, unorm_to_float(src, 32))
638 - } else {
639 - SWIZZLE_CONVERT(float, uint32_t, src)
640 - }
641 - break;
642 - case GL_INT:
643 - if (normalized) {
644 - SWIZZLE_CONVERT(float, int32_t, snorm_to_float(src, 32))
645 - } else {
646 - SWIZZLE_CONVERT(float, int32_t, src)
647 - }
648 - break;
649 - default:
650 - assert(!"Invalid channel type combination");
651 - }
652 - }
653 - break;
654 + convert_float(void_dst, num_dst_channels, void_src, src_type,
655 + num_src_channels, swizzle, normalized, count);
656 + break;
657 case GL_HALF_FLOAT:
658 - {
659 - const uint16_t one = _mesa_float_to_half(1.0f);
660 - switch (src_type) {
661 - case GL_FLOAT:
662 - SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src))
663 - break;
664 - case GL_HALF_FLOAT:
665 - SWIZZLE_CONVERT(uint16_t, uint16_t, src)
666 - break;
667 - case GL_UNSIGNED_BYTE:
668 - if (normalized) {
669 - SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_half(src, 8))
670 - } else {
671 - SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src))
672 - }
673 - break;
674 - case GL_BYTE:
675 - if (normalized) {
676 - SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_half(src, 8))
677 - } else {
678 - SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src))
679 - }
680 - break;
681 - case GL_UNSIGNED_SHORT:
682 - if (normalized) {
683 - SWIZZLE_CONVERT(uint16_t, uint16_t, unorm_to_half(src, 16))
684 - } else {
685 - SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src))
686 - }
687 - break;
688 - case GL_SHORT:
689 - if (normalized) {
690 - SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_half(src, 16))
691 - } else {
692 - SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src))
693 - }
694 - break;
695 - case GL_UNSIGNED_INT:
696 - if (normalized) {
697 - SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_half(src, 32))
698 - } else {
699 - SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src))
700 - }
701 - break;
702 - case GL_INT:
703 - if (normalized) {
704 - SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_half(src, 32))
705 - } else {
706 - SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_float_to_half(src))
707 - }
708 - break;
709 - default:
710 - assert(!"Invalid channel type combination");
711 - }
712 - }
713 - break;
714 + convert_half_float(void_dst, num_dst_channels, void_src, src_type,
715 + num_src_channels, swizzle, normalized, count);
716 + break;
717 case GL_UNSIGNED_BYTE:
718 - {
719 - const uint8_t one = normalized ? UINT8_MAX : 1;
720 - switch (src_type) {
721 - case GL_FLOAT:
722 - if (normalized) {
723 - SWIZZLE_CONVERT(uint8_t, float, float_to_unorm(src, 8))
724 - } else {
725 - SWIZZLE_CONVERT(uint8_t, float, (src < 0) ? 0 : src)
726 - }
727 - break;
728 - case GL_HALF_FLOAT:
729 - if (normalized) {
730 - SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_unorm(src, 8))
731 - } else {
732 - SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_uint(src))
733 - }
734 - break;
735 - case GL_UNSIGNED_BYTE:
736 - SWIZZLE_CONVERT(uint8_t, uint8_t, src)
737 - break;
738 - case GL_BYTE:
739 - if (normalized) {
740 - SWIZZLE_CONVERT(uint8_t, int8_t, snorm_to_unorm(src, 8, 8))
741 - } else {
742 - SWIZZLE_CONVERT(uint8_t, int8_t, (src < 0) ? 0 : src)
743 - }
744 - break;
745 - case GL_UNSIGNED_SHORT:
746 - if (normalized) {
747 - SWIZZLE_CONVERT(uint8_t, uint16_t, unorm_to_unorm(src, 16, 8))
748 - } else {
749 - SWIZZLE_CONVERT(uint8_t, uint16_t, src)
750 - }
751 - break;
752 - case GL_SHORT:
753 - if (normalized) {
754 - SWIZZLE_CONVERT(uint8_t, int16_t, snorm_to_unorm(src, 16, 8))
755 - } else {
756 - SWIZZLE_CONVERT(uint8_t, int16_t, (src < 0) ? 0 : src)
757 - }
758 - break;
759 - case GL_UNSIGNED_INT:
760 - if (normalized) {
761 - SWIZZLE_CONVERT(uint8_t, uint32_t, unorm_to_unorm(src, 32, 8))
762 - } else {
763 - SWIZZLE_CONVERT(uint8_t, uint32_t, src)
764 - }
765 - break;
766 - case GL_INT:
767 - if (normalized) {
768 - SWIZZLE_CONVERT(uint8_t, int32_t, snorm_to_unorm(src, 32, 8))
769 - } else {
770 - SWIZZLE_CONVERT(uint8_t, int32_t, (src < 0) ? 0 : src)
771 - }
772 - break;
773 - default:
774 - assert(!"Invalid channel type combination");
775 - }
776 - }
777 - break;
778 + convert_ubyte(void_dst, num_dst_channels, void_src, src_type,
779 + num_src_channels, swizzle, normalized, count);
780 + break;
781 case GL_BYTE:
782 - {
783 - const int8_t one = normalized ? INT8_MAX : 1;
784 - switch (src_type) {
785 - case GL_FLOAT:
786 - if (normalized) {
787 - SWIZZLE_CONVERT(uint8_t, float, float_to_snorm(src, 8))
788 - } else {
789 - SWIZZLE_CONVERT(uint8_t, float, src)
790 - }
791 - break;
792 - case GL_HALF_FLOAT:
793 - if (normalized) {
794 - SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_snorm(src, 8))
795 - } else {
796 - SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_float(src))
797 - }
798 - break;
799 - case GL_UNSIGNED_BYTE:
800 - if (normalized) {
801 - SWIZZLE_CONVERT(int8_t, uint8_t, unorm_to_snorm(src, 8, 8))
802 - } else {
803 - SWIZZLE_CONVERT(int8_t, uint8_t, src)
804 - }
805 - break;
806 - case GL_BYTE:
807 - SWIZZLE_CONVERT(int8_t, int8_t, src)
808 - break;
809 - case GL_UNSIGNED_SHORT:
810 - if (normalized) {
811 - SWIZZLE_CONVERT(int8_t, uint16_t, unorm_to_snorm(src, 16, 8))
812 - } else {
813 - SWIZZLE_CONVERT(int8_t, uint16_t, src)
814 - }
815 - break;
816 - case GL_SHORT:
817 - if (normalized) {
818 - SWIZZLE_CONVERT(int8_t, int16_t, snorm_to_snorm(src, 16, 8))
819 - } else {
820 - SWIZZLE_CONVERT(int8_t, int16_t, src)
821 - }
822 - break;
823 - case GL_UNSIGNED_INT:
824 - if (normalized) {
825 - SWIZZLE_CONVERT(int8_t, uint32_t, unorm_to_snorm(src, 32, 8))
826 - } else {
827 - SWIZZLE_CONVERT(int8_t, uint32_t, src)
828 - }
829 - break;
830 - case GL_INT:
831 - if (normalized) {
832 - SWIZZLE_CONVERT(int8_t, int32_t, snorm_to_snorm(src, 32, 8))
833 - } else {
834 - SWIZZLE_CONVERT(int8_t, int32_t, src)
835 - }
836 - break;
837 - default:
838 - assert(!"Invalid channel type combination");
839 - }
840 - }
841 - break;
842 + convert_byte(void_dst, num_dst_channels, void_src, src_type,
843 + num_src_channels, swizzle, normalized, count);
844 + break;
845 case GL_UNSIGNED_SHORT:
846 - {
847 - const uint16_t one = normalized ? UINT16_MAX : 1;
848 - switch (src_type) {
849 - case GL_FLOAT:
850 - if (normalized) {
851 - SWIZZLE_CONVERT(uint16_t, float, float_to_unorm(src, 16))
852 - } else {
853 - SWIZZLE_CONVERT(uint16_t, float, (src < 0) ? 0 : src)
854 - }
855 - break;
856 - case GL_HALF_FLOAT:
857 - if (normalized) {
858 - SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_unorm(src, 16))
859 - } else {
860 - SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_uint(src))
861 - }
862 - break;
863 - case GL_UNSIGNED_BYTE:
864 - if (normalized) {
865 - SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_unorm(src, 8, 16))
866 - } else {
867 - SWIZZLE_CONVERT(uint16_t, uint8_t, src)
868 - }
869 - break;
870 - case GL_BYTE:
871 - if (normalized) {
872 - SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_unorm(src, 8, 16))
873 - } else {
874 - SWIZZLE_CONVERT(uint16_t, int8_t, (src < 0) ? 0 : src)
875 - }
876 - break;
877 - case GL_UNSIGNED_SHORT:
878 - SWIZZLE_CONVERT(uint16_t, uint16_t, src)
879 - break;
880 - case GL_SHORT:
881 - if (normalized) {
882 - SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_unorm(src, 16, 16))
883 - } else {
884 - SWIZZLE_CONVERT(uint16_t, int16_t, (src < 0) ? 0 : src)
885 - }
886 - break;
887 - case GL_UNSIGNED_INT:
888 - if (normalized) {
889 - SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_unorm(src, 32, 16))
890 - } else {
891 - SWIZZLE_CONVERT(uint16_t, uint32_t, src)
892 - }
893 - break;
894 - case GL_INT:
895 - if (normalized) {
896 - SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_unorm(src, 32, 16))
897 - } else {
898 - SWIZZLE_CONVERT(uint16_t, int32_t, (src < 0) ? 0 : src)
899 - }
900 - break;
901 - default:
902 - assert(!"Invalid channel type combination");
903 - }
904 - }
905 - break;
906 + convert_ushort(void_dst, num_dst_channels, void_src, src_type,
907 + num_src_channels, swizzle, normalized, count);
908 + break;
909 case GL_SHORT:
910 - {
911 - const int16_t one = normalized ? INT16_MAX : 1;
912 - switch (src_type) {
913 - case GL_FLOAT:
914 - if (normalized) {
915 - SWIZZLE_CONVERT(uint16_t, float, float_to_snorm(src, 16))
916 - } else {
917 - SWIZZLE_CONVERT(uint16_t, float, src)
918 - }
919 - break;
920 - case GL_HALF_FLOAT:
921 - if (normalized) {
922 - SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_snorm(src, 16))
923 - } else {
924 - SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_float(src))
925 - }
926 - break;
927 - case GL_UNSIGNED_BYTE:
928 - if (normalized) {
929 - SWIZZLE_CONVERT(int16_t, uint8_t, unorm_to_snorm(src, 8, 16))
930 - } else {
931 - SWIZZLE_CONVERT(int16_t, uint8_t, src)
932 - }
933 - break;
934 - case GL_BYTE:
935 - if (normalized) {
936 - SWIZZLE_CONVERT(int16_t, int8_t, snorm_to_snorm(src, 8, 16))
937 - } else {
938 - SWIZZLE_CONVERT(int16_t, int8_t, src)
939 - }
940 - break;
941 - case GL_UNSIGNED_SHORT:
942 - if (normalized) {
943 - SWIZZLE_CONVERT(int16_t, uint16_t, unorm_to_snorm(src, 16, 16))
944 - } else {
945 - SWIZZLE_CONVERT(int16_t, uint16_t, src)
946 - }
947 - break;
948 - case GL_SHORT:
949 - SWIZZLE_CONVERT(int16_t, int16_t, src)
950 - break;
951 - case GL_UNSIGNED_INT:
952 - if (normalized) {
953 - SWIZZLE_CONVERT(int16_t, uint32_t, unorm_to_snorm(src, 32, 16))
954 - } else {
955 - SWIZZLE_CONVERT(int16_t, uint32_t, src)
956 - }
957 - break;
958 - case GL_INT:
959 - if (normalized) {
960 - SWIZZLE_CONVERT(int16_t, int32_t, snorm_to_snorm(src, 32, 16))
961 - } else {
962 - SWIZZLE_CONVERT(int16_t, int32_t, src)
963 - }
964 - break;
965 - default:
966 - assert(!"Invalid channel type combination");
967 - }
968 - }
969 - break;
970 + convert_short(void_dst, num_dst_channels, void_src, src_type,
971 + num_src_channels, swizzle, normalized, count);
972 + break;
973 case GL_UNSIGNED_INT:
974 - {
975 - const uint32_t one = normalized ? UINT32_MAX : 1;
976 - switch (src_type) { case GL_FLOAT:
977 - if (normalized) {
978 - SWIZZLE_CONVERT(uint32_t, float, float_to_unorm(src, 32))
979 - } else {
980 - SWIZZLE_CONVERT(uint32_t, float, (src < 0) ? 0 : src)
981 - }
982 - break;
983 - case GL_HALF_FLOAT:
984 - if (normalized) {
985 - SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_unorm(src, 32))
986 - } else {
987 - SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_uint(src))
988 - }
989 - break;
990 - case GL_UNSIGNED_BYTE:
991 - if (normalized) {
992 - SWIZZLE_CONVERT(uint32_t, uint8_t, unorm_to_unorm(src, 8, 32))
993 - } else {
994 - SWIZZLE_CONVERT(uint32_t, uint8_t, src)
995 - }
996 - break;
997 - case GL_BYTE:
998 - if (normalized) {
999 - SWIZZLE_CONVERT(uint32_t, int8_t, snorm_to_unorm(src, 8, 32))
1000 - } else {
1001 - SWIZZLE_CONVERT(uint32_t, int8_t, (src < 0) ? 0 : src)
1002 - }
1003 - break;
1004 - case GL_UNSIGNED_SHORT:
1005 - if (normalized) {
1006 - SWIZZLE_CONVERT(uint32_t, uint16_t, unorm_to_unorm(src, 16, 32))
1007 - } else {
1008 - SWIZZLE_CONVERT(uint32_t, uint16_t, src)
1009 - }
1010 - break;
1011 - case GL_SHORT:
1012 - if (normalized) {
1013 - SWIZZLE_CONVERT(uint32_t, int16_t, snorm_to_unorm(src, 16, 32))
1014 - } else {
1015 - SWIZZLE_CONVERT(uint32_t, int16_t, (src < 0) ? 0 : src)
1016 - }
1017 - break;
1018 - case GL_UNSIGNED_INT:
1019 - SWIZZLE_CONVERT(uint32_t, uint32_t, src)
1020 - break;
1021 - case GL_INT:
1022 - if (normalized) {
1023 - SWIZZLE_CONVERT(uint32_t, int32_t, snorm_to_unorm(src, 32, 32))
1024 - } else {
1025 - SWIZZLE_CONVERT(uint32_t, int32_t, (src < 0) ? 0 : src)
1026 - }
1027 - break;
1028 - default:
1029 - assert(!"Invalid channel type combination");
1030 - }
1031 - }
1032 - break;
1033 + convert_uint(void_dst, num_dst_channels, void_src, src_type,
1034 + num_src_channels, swizzle, normalized, count);
1035 + break;
1036 case GL_INT:
1037 - {
1038 - const int32_t one = normalized ? INT32_MAX : 1;
1039 - switch (src_type) {
1040 - case GL_FLOAT:
1041 - if (normalized) {
1042 - SWIZZLE_CONVERT(uint32_t, float, float_to_snorm(src, 32))
1043 - } else {
1044 - SWIZZLE_CONVERT(uint32_t, float, src)
1045 - }
1046 - break;
1047 - case GL_HALF_FLOAT:
1048 - if (normalized) {
1049 - SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_snorm(src, 32))
1050 - } else {
1051 - SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_float(src))
1052 - }
1053 - break;
1054 - case GL_UNSIGNED_BYTE:
1055 - if (normalized) {
1056 - SWIZZLE_CONVERT(int32_t, uint8_t, unorm_to_snorm(src, 8, 32))
1057 - } else {
1058 - SWIZZLE_CONVERT(int32_t, uint8_t, src)
1059 - }
1060 - break;
1061 - case GL_BYTE:
1062 - if (normalized) {
1063 - SWIZZLE_CONVERT(int32_t, int8_t, snorm_to_snorm(src, 8, 32))
1064 - } else {
1065 - SWIZZLE_CONVERT(int32_t, int8_t, src)
1066 - }
1067 - break;
1068 - case GL_UNSIGNED_SHORT:
1069 - if (normalized) {
1070 - SWIZZLE_CONVERT(int32_t, uint16_t, unorm_to_snorm(src, 16, 32))
1071 - } else {
1072 - SWIZZLE_CONVERT(int32_t, uint16_t, src)
1073 - }
1074 - break;
1075 - case GL_SHORT:
1076 - if (normalized) {
1077 - SWIZZLE_CONVERT(int32_t, int16_t, snorm_to_snorm(src, 16, 32))
1078 - } else {
1079 - SWIZZLE_CONVERT(int32_t, int16_t, src)
1080 - }
1081 - break;
1082 - case GL_UNSIGNED_INT:
1083 - if (normalized) {
1084 - SWIZZLE_CONVERT(int32_t, uint32_t, unorm_to_snorm(src, 32, 32))
1085 - } else {
1086 - SWIZZLE_CONVERT(int32_t, uint32_t, src)
1087 - }
1088 - break;
1089 - case GL_INT:
1090 - SWIZZLE_CONVERT(int32_t, int32_t, src)
1091 - break;
1092 - default:
1093 - assert(!"Invalid channel type combination");
1094 - }
1095 - }
1096 - break;
1097 + convert_int(void_dst, num_dst_channels, void_src, src_type,
1098 + num_src_channels, swizzle, normalized, count);
1099 + break;
1100 default:
1101 assert(!"Invalid channel type");
1102 }
1103 --
1104 2.0.5
Report Message
Find on MARC Find on Google Groups