panfrost: add missing dependency on midgard_pack.h
[mesa.git] / src / util / format / u_format_pack.py
1
2 '''
3 /**************************************************************************
4 *
5 * Copyright 2009-2010 VMware, Inc.
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
18 * of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
23 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 *
28 **************************************************************************/
29
30 /**
31 * @file
32 * Pixel format packing and unpacking functions.
33 *
34 * @author Jose Fonseca <jfonseca@vmware.com>
35 */
36 '''
37
38
39 from __future__ import division, print_function
40
41 import sys
42
43 from u_format_parse import *
44
45
46 if sys.version_info < (3, 0):
47 integer_types = (int, long)
48
49 else:
50 integer_types = (int, )
51
52
53 def inv_swizzles(swizzles):
54 '''Return an array[4] of inverse swizzle terms'''
55 '''Only pick the first matching value to avoid l8 getting blue and i8 getting alpha'''
56 inv_swizzle = [None]*4
57 for i in range(4):
58 swizzle = swizzles[i]
59 if swizzle < 4 and inv_swizzle[swizzle] == None:
60 inv_swizzle[swizzle] = i
61 return inv_swizzle
62
63 def print_channels(format, func):
64 if format.nr_channels() <= 1:
65 func(format.le_channels, format.le_swizzles)
66 else:
67 if (format.le_channels == format.be_channels and
68 [c.shift for c in format.le_channels] ==
69 [c.shift for c in format.be_channels] and
70 format.le_swizzles == format.be_swizzles):
71 func(format.le_channels, format.le_swizzles)
72 else:
73 print('#if UTIL_ARCH_BIG_ENDIAN')
74 func(format.be_channels, format.be_swizzles)
75 print('#else')
76 func(format.le_channels, format.le_swizzles)
77 print('#endif')
78
79 def generate_format_type(format):
80 '''Generate a structure that describes the format.'''
81
82 assert format.layout == PLAIN
83
84 def generate_bitfields(channels, swizzles):
85 for channel in channels:
86 if channel.type == VOID:
87 if channel.size:
88 print(' unsigned %s:%u;' % (channel.name, channel.size))
89 elif channel.type == UNSIGNED:
90 print(' unsigned %s:%u;' % (channel.name, channel.size))
91 elif channel.type in (SIGNED, FIXED):
92 print(' int %s:%u;' % (channel.name, channel.size))
93 elif channel.type == FLOAT:
94 if channel.size == 64:
95 print(' double %s;' % (channel.name))
96 elif channel.size == 32:
97 print(' float %s;' % (channel.name))
98 else:
99 print(' unsigned %s:%u;' % (channel.name, channel.size))
100 else:
101 assert 0
102
103 def generate_full_fields(channels, swizzles):
104 for channel in channels:
105 assert channel.size % 8 == 0 and is_pot(channel.size)
106 if channel.type == VOID:
107 if channel.size:
108 print(' uint%u_t %s;' % (channel.size, channel.name))
109 elif channel.type == UNSIGNED:
110 print(' uint%u_t %s;' % (channel.size, channel.name))
111 elif channel.type in (SIGNED, FIXED):
112 print(' int%u_t %s;' % (channel.size, channel.name))
113 elif channel.type == FLOAT:
114 if channel.size == 64:
115 print(' double %s;' % (channel.name))
116 elif channel.size == 32:
117 print(' float %s;' % (channel.name))
118 elif channel.size == 16:
119 print(' uint16_t %s;' % (channel.name))
120 else:
121 assert 0
122 else:
123 assert 0
124
125 use_bitfields = False
126 for channel in format.le_channels:
127 if channel.size % 8 or not is_pot(channel.size):
128 use_bitfields = True
129
130 print('struct util_format_%s {' % format.short_name())
131 if use_bitfields:
132 print_channels(format, generate_bitfields)
133 else:
134 print_channels(format, generate_full_fields)
135 print('};')
136 print()
137
138
139 def is_format_supported(format):
140 '''Determines whether we actually have the plumbing necessary to generate the
141 to read/write to/from this format.'''
142
143 # FIXME: Ideally we would support any format combination here.
144
145 if format.layout != PLAIN:
146 return False
147
148 for i in range(4):
149 channel = format.le_channels[i]
150 if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT, FIXED):
151 return False
152 if channel.type == FLOAT and channel.size not in (16, 32, 64):
153 return False
154
155 return True
156
157 def native_type(format):
158 '''Get the native appropriate for a format.'''
159
160 if format.name == 'PIPE_FORMAT_R11G11B10_FLOAT':
161 return 'uint32_t'
162 if format.name == 'PIPE_FORMAT_R9G9B9E5_FLOAT':
163 return 'uint32_t'
164
165 if format.layout == PLAIN:
166 if not format.is_array():
167 # For arithmetic pixel formats return the integer type that matches the whole pixel
168 return 'uint%u_t' % format.block_size()
169 else:
170 # For array pixel formats return the integer type that matches the color channel
171 channel = format.array_element()
172 if channel.type in (UNSIGNED, VOID):
173 return 'uint%u_t' % channel.size
174 elif channel.type in (SIGNED, FIXED):
175 return 'int%u_t' % channel.size
176 elif channel.type == FLOAT:
177 if channel.size == 16:
178 return 'uint16_t'
179 elif channel.size == 32:
180 return 'float'
181 elif channel.size == 64:
182 return 'double'
183 else:
184 assert False
185 else:
186 assert False
187 else:
188 assert False
189
190
191 def intermediate_native_type(bits, sign):
192 '''Find a native type adequate to hold intermediate results of the request bit size.'''
193
194 bytes = 4 # don't use anything smaller than 32bits
195 while bytes * 8 < bits:
196 bytes *= 2
197 bits = bytes*8
198
199 if sign:
200 return 'int%u_t' % bits
201 else:
202 return 'uint%u_t' % bits
203
204
205 def get_one_shift(type):
206 '''Get the number of the bit that matches unity for this type.'''
207 if type.type == 'FLOAT':
208 assert False
209 if not type.norm:
210 return 0
211 if type.type == UNSIGNED:
212 return type.size
213 if type.type == SIGNED:
214 return type.size - 1
215 if type.type == FIXED:
216 return type.size / 2
217 assert False
218
219
220 def truncate_mantissa(x, bits):
221 '''Truncate an integer so it can be represented exactly with a floating
222 point mantissa'''
223
224 assert isinstance(x, integer_types)
225
226 s = 1
227 if x < 0:
228 s = -1
229 x = -x
230
231 # We can represent integers up to mantissa + 1 bits exactly
232 mask = (1 << (bits + 1)) - 1
233
234 # Slide the mask until the MSB matches
235 shift = 0
236 while (x >> shift) & ~mask:
237 shift += 1
238
239 x &= mask << shift
240 x *= s
241 return x
242
243
244 def value_to_native(type, value):
245 '''Get the value of unity for this type.'''
246 if type.type == FLOAT:
247 if type.size <= 32 \
248 and isinstance(value, integer_types):
249 return truncate_mantissa(value, 23)
250 return value
251 if type.type == FIXED:
252 return int(value * (1 << (type.size // 2)))
253 if not type.norm:
254 return int(value)
255 if type.type == UNSIGNED:
256 return int(value * ((1 << type.size) - 1))
257 if type.type == SIGNED:
258 return int(value * ((1 << (type.size - 1)) - 1))
259 assert False
260
261
262 def native_to_constant(type, value):
263 '''Get the value of unity for this type.'''
264 if type.type == FLOAT:
265 if type.size <= 32:
266 return "%.1ff" % float(value)
267 else:
268 return "%.1f" % float(value)
269 else:
270 return str(int(value))
271
272
273 def get_one(type):
274 '''Get the value of unity for this type.'''
275 return value_to_native(type, 1)
276
277
278 def clamp_expr(src_channel, dst_channel, dst_native_type, value):
279 '''Generate the expression to clamp the value in the source type to the
280 destination type range.'''
281
282 if src_channel == dst_channel:
283 return value
284
285 src_min = src_channel.min()
286 src_max = src_channel.max()
287 dst_min = dst_channel.min()
288 dst_max = dst_channel.max()
289
290 # Translate the destination range to the src native value
291 dst_min_native = native_to_constant(src_channel, value_to_native(src_channel, dst_min))
292 dst_max_native = native_to_constant(src_channel, value_to_native(src_channel, dst_max))
293
294 if src_min < dst_min and src_max > dst_max:
295 return 'CLAMP(%s, %s, %s)' % (value, dst_min_native, dst_max_native)
296
297 if src_max > dst_max:
298 return 'MIN2(%s, %s)' % (value, dst_max_native)
299
300 if src_min < dst_min:
301 return 'MAX2(%s, %s)' % (value, dst_min_native)
302
303 return value
304
305
306 def conversion_expr(src_channel,
307 dst_channel, dst_native_type,
308 value,
309 clamp=True,
310 src_colorspace = RGB,
311 dst_colorspace = RGB):
312 '''Generate the expression to convert a value between two types.'''
313
314 if src_colorspace != dst_colorspace:
315 if src_colorspace == SRGB:
316 assert src_channel.type == UNSIGNED
317 assert src_channel.norm
318 assert src_channel.size <= 8
319 assert src_channel.size >= 4
320 assert dst_colorspace == RGB
321 if src_channel.size < 8:
322 value = '%s << %x | %s >> %x' % (value, 8 - src_channel.size, value, 2 * src_channel.size - 8)
323 if dst_channel.type == FLOAT:
324 return 'util_format_srgb_8unorm_to_linear_float(%s)' % value
325 else:
326 assert dst_channel.type == UNSIGNED
327 assert dst_channel.norm
328 assert dst_channel.size == 8
329 return 'util_format_srgb_to_linear_8unorm(%s)' % value
330 elif dst_colorspace == SRGB:
331 assert dst_channel.type == UNSIGNED
332 assert dst_channel.norm
333 assert dst_channel.size <= 8
334 assert src_colorspace == RGB
335 if src_channel.type == FLOAT:
336 value = 'util_format_linear_float_to_srgb_8unorm(%s)' % value
337 else:
338 assert src_channel.type == UNSIGNED
339 assert src_channel.norm
340 assert src_channel.size == 8
341 value = 'util_format_linear_to_srgb_8unorm(%s)' % value
342 # XXX rounding is all wrong.
343 if dst_channel.size < 8:
344 return '%s >> %x' % (value, 8 - dst_channel.size)
345 else:
346 return value
347 elif src_colorspace == ZS:
348 pass
349 elif dst_colorspace == ZS:
350 pass
351 else:
352 assert 0
353
354 if src_channel == dst_channel:
355 return value
356
357 src_type = src_channel.type
358 src_size = src_channel.size
359 src_norm = src_channel.norm
360 src_pure = src_channel.pure
361
362 # Promote half to float
363 if src_type == FLOAT and src_size == 16:
364 value = 'util_half_to_float(%s)' % value
365 src_size = 32
366
367 # Special case for float <-> ubytes for more accurate results
368 # Done before clamping since these functions already take care of that
369 if src_type == UNSIGNED and src_norm and src_size == 8 and dst_channel.type == FLOAT and dst_channel.size == 32:
370 return 'ubyte_to_float(%s)' % value
371 if src_type == FLOAT and src_size == 32 and dst_channel.type == UNSIGNED and dst_channel.norm and dst_channel.size == 8:
372 return 'float_to_ubyte(%s)' % value
373
374 if clamp:
375 if dst_channel.type != FLOAT or src_type != FLOAT:
376 value = clamp_expr(src_channel, dst_channel, dst_native_type, value)
377
378 if src_type in (SIGNED, UNSIGNED) and dst_channel.type in (SIGNED, UNSIGNED):
379 if not src_norm and not dst_channel.norm:
380 # neither is normalized -- just cast
381 return '(%s)%s' % (dst_native_type, value)
382
383 src_one = get_one(src_channel)
384 dst_one = get_one(dst_channel)
385
386 if src_one > dst_one and src_norm and dst_channel.norm:
387 # We can just bitshift
388 src_shift = get_one_shift(src_channel)
389 dst_shift = get_one_shift(dst_channel)
390 value = '(%s >> %s)' % (value, src_shift - dst_shift)
391 else:
392 # We need to rescale using an intermediate type big enough to hold the multiplication of both
393 tmp_native_type = intermediate_native_type(src_size + dst_channel.size, src_channel.sign and dst_channel.sign)
394 value = '((%s)%s)' % (tmp_native_type, value)
395 value = '(%s * 0x%x / 0x%x)' % (value, dst_one, src_one)
396 value = '(%s)%s' % (dst_native_type, value)
397 return value
398
399 # Promote to either float or double
400 if src_type != FLOAT:
401 if src_norm or src_type == FIXED:
402 one = get_one(src_channel)
403 if src_size <= 23:
404 value = '(%s * (1.0f/0x%x))' % (value, one)
405 if dst_channel.size <= 32:
406 value = '(float)%s' % value
407 src_size = 32
408 else:
409 # bigger than single precision mantissa, use double
410 value = '(%s * (1.0/0x%x))' % (value, one)
411 src_size = 64
412 src_norm = False
413 else:
414 if src_size <= 23 or dst_channel.size <= 32:
415 value = '(float)%s' % value
416 src_size = 32
417 else:
418 # bigger than single precision mantissa, use double
419 value = '(double)%s' % value
420 src_size = 64
421 src_type = FLOAT
422
423 # Convert double or float to non-float
424 if dst_channel.type != FLOAT:
425 if dst_channel.norm or dst_channel.type == FIXED:
426 dst_one = get_one(dst_channel)
427 if dst_channel.size <= 23:
428 value = 'util_iround(%s * 0x%x)' % (value, dst_one)
429 else:
430 # bigger than single precision mantissa, use double
431 value = '(%s * (double)0x%x)' % (value, dst_one)
432 value = '(%s)%s' % (dst_native_type, value)
433 else:
434 # Cast double to float when converting to either half or float
435 if dst_channel.size <= 32 and src_size > 32:
436 value = '(float)%s' % value
437 src_size = 32
438
439 if dst_channel.size == 16:
440 value = 'util_float_to_half_rtz(%s)' % value
441 elif dst_channel.size == 64 and src_size < 64:
442 value = '(double)%s' % value
443
444 return value
445
446
447 def generate_unpack_kernel(format, dst_channel, dst_native_type):
448
449 if not is_format_supported(format):
450 return
451
452 assert format.layout == PLAIN
453
454 def unpack_from_bitmask(channels, swizzles):
455 depth = format.block_size()
456 print(' uint%u_t value = *(const uint%u_t *)src;' % (depth, depth))
457
458 # Declare the intermediate variables
459 for i in range(format.nr_channels()):
460 src_channel = channels[i]
461 if src_channel.type == UNSIGNED:
462 print(' uint%u_t %s;' % (depth, src_channel.name))
463 elif src_channel.type == SIGNED:
464 print(' int%u_t %s;' % (depth, src_channel.name))
465
466 # Compute the intermediate unshifted values
467 for i in range(format.nr_channels()):
468 src_channel = channels[i]
469 value = 'value'
470 shift = src_channel.shift
471 if src_channel.type == UNSIGNED:
472 if shift:
473 value = '%s >> %u' % (value, shift)
474 if shift + src_channel.size < depth:
475 value = '(%s) & 0x%x' % (value, (1 << src_channel.size) - 1)
476 elif src_channel.type == SIGNED:
477 if shift + src_channel.size < depth:
478 # Align the sign bit
479 lshift = depth - (shift + src_channel.size)
480 value = '%s << %u' % (value, lshift)
481 # Cast to signed
482 value = '(int%u_t)(%s) ' % (depth, value)
483 if src_channel.size < depth:
484 # Align the LSB bit
485 rshift = depth - src_channel.size
486 value = '(%s) >> %u' % (value, rshift)
487 else:
488 value = None
489
490 if value is not None:
491 print(' %s = %s;' % (src_channel.name, value))
492
493 # Convert, swizzle, and store final values
494 for i in range(4):
495 swizzle = swizzles[i]
496 if swizzle < 4:
497 src_channel = channels[swizzle]
498 src_colorspace = format.colorspace
499 if src_colorspace == SRGB and i == 3:
500 # Alpha channel is linear
501 src_colorspace = RGB
502 value = src_channel.name
503 value = conversion_expr(src_channel,
504 dst_channel, dst_native_type,
505 value,
506 src_colorspace = src_colorspace)
507 elif swizzle == SWIZZLE_0:
508 value = '0'
509 elif swizzle == SWIZZLE_1:
510 value = get_one(dst_channel)
511 elif swizzle == SWIZZLE_NONE:
512 value = '0'
513 else:
514 assert False
515 print(' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i]))
516
517 def unpack_from_struct(channels, swizzles):
518 print(' struct util_format_%s pixel;' % format.short_name())
519 print(' memcpy(&pixel, src, sizeof pixel);')
520
521 for i in range(4):
522 swizzle = swizzles[i]
523 if swizzle < 4:
524 src_channel = channels[swizzle]
525 src_colorspace = format.colorspace
526 if src_colorspace == SRGB and i == 3:
527 # Alpha channel is linear
528 src_colorspace = RGB
529 value = 'pixel.%s' % src_channel.name
530 value = conversion_expr(src_channel,
531 dst_channel, dst_native_type,
532 value,
533 src_colorspace = src_colorspace)
534 elif swizzle == SWIZZLE_0:
535 value = '0'
536 elif swizzle == SWIZZLE_1:
537 value = get_one(dst_channel)
538 elif swizzle == SWIZZLE_NONE:
539 value = '0'
540 else:
541 assert False
542 print(' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i]))
543
544 if format.is_bitmask():
545 print_channels(format, unpack_from_bitmask)
546 else:
547 print_channels(format, unpack_from_struct)
548
549
550 def generate_pack_kernel(format, src_channel, src_native_type):
551
552 if not is_format_supported(format):
553 return
554
555 dst_native_type = native_type(format)
556
557 assert format.layout == PLAIN
558
559 def pack_into_bitmask(channels, swizzles):
560 inv_swizzle = inv_swizzles(swizzles)
561
562 depth = format.block_size()
563 print(' uint%u_t value = 0;' % depth)
564
565 for i in range(4):
566 dst_channel = channels[i]
567 shift = dst_channel.shift
568 if inv_swizzle[i] is not None:
569 value ='src[%u]' % inv_swizzle[i]
570 dst_colorspace = format.colorspace
571 if dst_colorspace == SRGB and inv_swizzle[i] == 3:
572 # Alpha channel is linear
573 dst_colorspace = RGB
574 value = conversion_expr(src_channel,
575 dst_channel, dst_native_type,
576 value,
577 dst_colorspace = dst_colorspace)
578 if dst_channel.type in (UNSIGNED, SIGNED):
579 if shift + dst_channel.size < depth:
580 value = '(%s) & 0x%x' % (value, (1 << dst_channel.size) - 1)
581 if shift:
582 value = '(uint32_t)(%s) << %u' % (value, shift)
583 if dst_channel.type == SIGNED:
584 # Cast to unsigned
585 value = '(uint%u_t)(%s) ' % (depth, value)
586 else:
587 value = None
588 if value is not None:
589 print(' value |= %s;' % (value))
590
591 print(' *(uint%u_t *)dst = value;' % depth)
592
593 def pack_into_struct(channels, swizzles):
594 inv_swizzle = inv_swizzles(swizzles)
595
596 print(' struct util_format_%s pixel = {0};' % format.short_name())
597
598 for i in range(4):
599 dst_channel = channels[i]
600 width = dst_channel.size
601 if inv_swizzle[i] is None:
602 continue
603 dst_colorspace = format.colorspace
604 if dst_colorspace == SRGB and inv_swizzle[i] == 3:
605 # Alpha channel is linear
606 dst_colorspace = RGB
607 value ='src[%u]' % inv_swizzle[i]
608 value = conversion_expr(src_channel,
609 dst_channel, dst_native_type,
610 value,
611 dst_colorspace = dst_colorspace)
612 print(' pixel.%s = %s;' % (dst_channel.name, value))
613
614 print(' memcpy(dst, &pixel, sizeof pixel);')
615
616 if format.is_bitmask():
617 print_channels(format, pack_into_bitmask)
618 else:
619 print_channels(format, pack_into_struct)
620
621
622 def generate_format_unpack(format, dst_channel, dst_native_type, dst_suffix):
623 '''Generate the function to unpack pixels from a particular format'''
624
625 name = format.short_name()
626
627 if "8unorm" in dst_suffix:
628 dst_proto_type = dst_native_type
629 else:
630 dst_proto_type = 'void'
631
632 print('static inline void')
633 print('util_format_%s_unpack_%s(%s *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)' % (name, dst_suffix, dst_proto_type))
634 print('{')
635
636 if is_format_supported(format):
637 print(' unsigned x, y;')
638 print(' for(y = 0; y < height; y += %u) {' % (format.block_height,))
639 print(' %s *dst = dst_row;' % (dst_native_type))
640 print(' const uint8_t *src = src_row;')
641 print(' for(x = 0; x < width; x += %u) {' % (format.block_width,))
642
643 generate_unpack_kernel(format, dst_channel, dst_native_type)
644
645 print(' src += %u;' % (format.block_size() / 8,))
646 print(' dst += 4;')
647 print(' }')
648 print(' src_row += src_stride;')
649 print(' dst_row = (uint8_t *)dst_row + dst_stride;')
650 print(' }')
651
652 print('}')
653 print()
654
655
656 def generate_format_pack(format, src_channel, src_native_type, src_suffix):
657 '''Generate the function to pack pixels to a particular format'''
658
659 name = format.short_name()
660
661 print('static inline void')
662 print('util_format_%s_pack_%s(uint8_t *dst_row, unsigned dst_stride, const %s *src_row, unsigned src_stride, unsigned width, unsigned height)' % (name, src_suffix, src_native_type))
663 print('{')
664
665 if is_format_supported(format):
666 print(' unsigned x, y;')
667 print(' for(y = 0; y < height; y += %u) {' % (format.block_height,))
668 print(' const %s *src = src_row;' % (src_native_type))
669 print(' uint8_t *dst = dst_row;')
670 print(' for(x = 0; x < width; x += %u) {' % (format.block_width,))
671
672 generate_pack_kernel(format, src_channel, src_native_type)
673
674 print(' src += 4;')
675 print(' dst += %u;' % (format.block_size() / 8,))
676 print(' }')
677 print(' dst_row += dst_stride;')
678 print(' src_row += src_stride/sizeof(*src_row);')
679 print(' }')
680
681 print('}')
682 print()
683
684
685 def generate_format_fetch(format, dst_channel, dst_native_type, dst_suffix):
686 '''Generate the function to unpack pixels from a particular format'''
687
688 name = format.short_name()
689
690 print('static inline void')
691 print('util_format_%s_fetch_%s(%s *dst, const uint8_t *src, UNUSED unsigned i, UNUSED unsigned j)' % (name, dst_suffix, dst_native_type))
692 print('{')
693
694 if is_format_supported(format):
695 generate_unpack_kernel(format, dst_channel, dst_native_type)
696
697 print('}')
698 print()
699
700
701 def is_format_hand_written(format):
702 return format.layout != PLAIN or format.colorspace == ZS
703
704
705 def generate(formats):
706 print()
707 print('#include "pipe/p_compiler.h"')
708 print('#include "util/u_math.h"')
709 print('#include "util/u_half.h"')
710 print('#include "u_format.h"')
711 print('#include "u_format_other.h"')
712 print('#include "util/format_srgb.h"')
713 print('#include "u_format_yuv.h"')
714 print('#include "u_format_zs.h"')
715 print()
716
717 for format in formats:
718 if not is_format_hand_written(format):
719
720 if is_format_supported(format) and not format.is_bitmask():
721 generate_format_type(format)
722
723 if format.is_pure_unsigned():
724 native_type = 'unsigned'
725 suffix = 'unsigned'
726 channel = Channel(UNSIGNED, False, True, 32)
727
728 generate_format_unpack(format, channel, native_type, suffix)
729 generate_format_pack(format, channel, native_type, suffix)
730 generate_format_fetch(format, channel, native_type, suffix)
731
732 channel = Channel(SIGNED, False, True, 32)
733 native_type = 'int'
734 suffix = 'signed'
735 generate_format_pack(format, channel, native_type, suffix)
736 elif format.is_pure_signed():
737 native_type = 'int'
738 suffix = 'signed'
739 channel = Channel(SIGNED, False, True, 32)
740
741 generate_format_unpack(format, channel, native_type, suffix)
742 generate_format_pack(format, channel, native_type, suffix)
743 generate_format_fetch(format, channel, native_type, suffix)
744
745 native_type = 'unsigned'
746 suffix = 'unsigned'
747 channel = Channel(UNSIGNED, False, True, 32)
748 generate_format_pack(format, channel, native_type, suffix)
749 else:
750 channel = Channel(FLOAT, False, False, 32)
751 native_type = 'float'
752 suffix = 'rgba_float'
753
754 generate_format_unpack(format, channel, native_type, suffix)
755 generate_format_pack(format, channel, native_type, suffix)
756 generate_format_fetch(format, channel, native_type, suffix)
757
758 channel = Channel(UNSIGNED, True, False, 8)
759 native_type = 'uint8_t'
760 suffix = 'rgba_8unorm'
761
762 generate_format_unpack(format, channel, native_type, suffix)
763 generate_format_pack(format, channel, native_type, suffix)
764