X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Futil%2Fu_format_pack.py;h=a2327196e6f631fd64bee7c3d0ab2791683a69c1;hb=1b592d30c51696eeeadca7a55b603c543dfdc3cf;hp=0c1bbc84c172a5dba89586dd06a74d7931b3eec3;hpb=ff20543c815a14fddad1efaaef1610454a1924d4;p=mesa.git diff --git a/src/gallium/auxiliary/util/u_format_pack.py b/src/gallium/auxiliary/util/u_format_pack.py index 0c1bbc84c17..a2327196e6f 100644 --- a/src/gallium/auxiliary/util/u_format_pack.py +++ b/src/gallium/auxiliary/util/u_format_pack.py @@ -1,4 +1,3 @@ -#!/usr/bin/env python ''' /************************************************************************** @@ -37,30 +36,36 @@ ''' -import sys -import math - from u_format_parse import * +def inv_swizzles(swizzles): + '''Return an array[4] of inverse swizzle terms''' + '''Only pick the first matching value to avoid l8 getting blue and i8 getting alpha''' + inv_swizzle = [None]*4 + for i in range(4): + swizzle = swizzles[i] + if swizzle < 4 and inv_swizzle[swizzle] == None: + inv_swizzle[swizzle] = i + return inv_swizzle + +def print_channels(format, func): + if format.nr_channels() <= 1: + func(format.le_channels, format.le_swizzles) + else: + print '#ifdef PIPE_ARCH_BIG_ENDIAN' + func(format.be_channels, format.be_swizzles) + print '#else' + func(format.le_channels, format.le_swizzles) + print '#endif' + def generate_format_type(format): '''Generate a structure that describes the format.''' assert format.layout == PLAIN - print 'union util_format_%s {' % format.short_name() - - if format.block_size() in (8, 16, 32, 64): - print ' uint%u_t value;' % (format.block_size(),) - - use_bitfields = False - for channel in format.channels: - if channel.size % 8 or not is_pot(channel.size): - use_bitfields = True - - print ' struct {' - for channel in format.channels: - if use_bitfields: + def generate_bitfields(channels, swizzles): + for channel in channels: if channel.type == VOID: if channel.size: print ' unsigned %s:%u;' % (channel.name, channel.size) @@ -77,7 +82,9 @@ def generate_format_type(format): print ' unsigned %s:%u;' % (channel.name, channel.size) else: assert 0 - else: + + def generate_full_fields(channels, swizzles): + for channel in channels: assert channel.size % 8 == 0 and is_pot(channel.size) if channel.type == VOID: if channel.size: @@ -97,18 +104,25 @@ def generate_format_type(format): assert 0 else: assert 0 - print ' } chan;' - print '};' - print + print 'union util_format_%s {' % format.short_name() + + if format.block_size() in (8, 16, 32, 64): + print ' uint%u_t value;' % (format.block_size(),) -def bswap_format(format): - '''Generate a structure that describes the format.''' + use_bitfields = False + for channel in format.le_channels: + if channel.size % 8 or not is_pot(channel.size): + use_bitfields = True - if format.is_bitmask() and not format.is_array() and format.block_size() > 8: - print '#ifdef PIPE_ARCH_BIG_ENDIAN' - print ' pixel.value = util_bswap%u(pixel.value);' % format.block_size() - print '#endif' + print ' struct {' + if use_bitfields: + print_channels(format, generate_bitfields) + else: + print_channels(format, generate_full_fields) + print ' } chan;' + print '};' + print def is_format_supported(format): @@ -121,7 +135,7 @@ def is_format_supported(format): return False for i in range(4): - channel = format.channels[i] + channel = format.le_channels[i] if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT, FIXED): return False if channel.type == FLOAT and channel.size not in (16, 32, 64): @@ -129,17 +143,21 @@ def is_format_supported(format): return True - def native_type(format): '''Get the native appropriate for a format.''' + if format.name == 'PIPE_FORMAT_R11G11B10_FLOAT': + return 'uint32_t' + if format.name == 'PIPE_FORMAT_R9G9B9E5_FLOAT': + return 'uint32_t' + if format.layout == PLAIN: if not format.is_array(): # For arithmetic pixel formats return the integer type that matches the whole pixel return 'uint%u_t' % format.block_size() else: # For array pixel formats return the integer type that matches the color channel - channel = format.channels[0] + channel = format.array_element() if channel.type in (UNSIGNED, VOID): return 'uint%u_t' % channel.size elif channel.type in (SIGNED, FIXED): @@ -188,9 +206,36 @@ def get_one_shift(type): assert False +def truncate_mantissa(x, bits): + '''Truncate an integer so it can be represented exactly with a floating + point mantissa''' + + assert isinstance(x, (int, long)) + + s = 1 + if x < 0: + s = -1 + x = -x + + # We can represent integers up to mantissa + 1 bits exactly + mask = (1 << (bits + 1)) - 1 + + # Slide the mask until the MSB matches + shift = 0 + while (x >> shift) & ~mask: + shift += 1 + + x &= mask << shift + x *= s + return x + + def value_to_native(type, value): '''Get the value of unity for this type.''' if type.type == FLOAT: + if type.size <= 32 \ + and isinstance(value, (int, long)): + return truncate_mantissa(value, 23) return value if type.type == FIXED: return int(value * (1 << (type.size/2))) @@ -207,9 +252,9 @@ def native_to_constant(type, value): '''Get the value of unity for this type.''' if type.type == FLOAT: if type.size <= 32: - return "%ff" % value + return "%.1ff" % float(value) else: - return "%ff" % value + return "%.1f" % float(value) else: return str(int(value)) @@ -232,8 +277,8 @@ def clamp_expr(src_channel, dst_channel, dst_native_type, value): dst_max = dst_channel.max() # Translate the destination range to the src native value - dst_min_native = value_to_native(src_channel, dst_min) - dst_max_native = value_to_native(src_channel, dst_max) + dst_min_native = native_to_constant(src_channel, value_to_native(src_channel, dst_min)) + dst_max_native = native_to_constant(src_channel, value_to_native(src_channel, dst_max)) if src_min < dst_min and src_max > dst_max: return 'CLAMP(%s, %s, %s)' % (value, dst_min_native, dst_max_native) @@ -259,8 +304,11 @@ def conversion_expr(src_channel, if src_colorspace == SRGB: assert src_channel.type == UNSIGNED assert src_channel.norm - assert src_channel.size == 8 + assert src_channel.size <= 8 + assert src_channel.size >= 4 assert dst_colorspace == RGB + if src_channel.size < 8: + value = '%s << %x | %s >> %x' % (value, 8 - src_channel.size, value, 2 * src_channel.size - 8) if dst_channel.type == FLOAT: return 'util_format_srgb_8unorm_to_linear_float(%s)' % value else: @@ -271,15 +319,20 @@ def conversion_expr(src_channel, elif dst_colorspace == SRGB: assert dst_channel.type == UNSIGNED assert dst_channel.norm - assert dst_channel.size == 8 + assert dst_channel.size <= 8 assert src_colorspace == RGB if src_channel.type == FLOAT: - return 'util_format_linear_float_to_srgb_8unorm(%s)' % value + value = 'util_format_linear_float_to_srgb_8unorm(%s)' % value else: assert src_channel.type == UNSIGNED assert src_channel.norm assert src_channel.size == 8 - return 'util_format_linear_to_srgb_8unorm(%s)' % value + value = 'util_format_linear_to_srgb_8unorm(%s)' % value + # XXX rounding is all wrong. + if dst_channel.size < 8: + return '%s >> %x' % (value, 8 - dst_channel.size) + else: + return value elif src_colorspace == ZS: pass elif dst_colorspace == ZS: @@ -293,6 +346,7 @@ def conversion_expr(src_channel, src_type = src_channel.type src_size = src_channel.size src_norm = src_channel.norm + src_pure = src_channel.pure # Promote half to float if src_type == FLOAT and src_size == 16: @@ -360,7 +414,7 @@ def conversion_expr(src_channel, if dst_channel.norm or dst_channel.type == FIXED: dst_one = get_one(dst_channel) if dst_channel.size <= 23: - value = '(%s * 0x%x)' % (value, dst_one) + value = 'util_iround(%s * 0x%x)' % (value, dst_one) else: # bigger than single precision mantissa, use double value = '(%s * (double)0x%x)' % (value, dst_one) @@ -388,28 +442,23 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type): src_native_type = native_type(format) - if format.is_bitmask(): + def unpack_from_bitmask(channels, swizzles): depth = format.block_size() print ' uint%u_t value = *(const uint%u_t *)src;' % (depth, depth) # Declare the intermediate variables for i in range(format.nr_channels()): - src_channel = format.channels[i] + src_channel = channels[i] if src_channel.type == UNSIGNED: print ' uint%u_t %s;' % (depth, src_channel.name) elif src_channel.type == SIGNED: print ' int%u_t %s;' % (depth, src_channel.name) - if depth > 8: - print '#ifdef PIPE_ARCH_BIG_ENDIAN' - print ' value = util_bswap%u(value);' % depth - print '#endif' - # Compute the intermediate unshifted values - shift = 0 for i in range(format.nr_channels()): - src_channel = format.channels[i] + src_channel = channels[i] value = 'value' + shift = src_channel.shift if src_channel.type == UNSIGNED: if shift: value = '%s >> %u' % (value, shift) @@ -432,13 +481,11 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type): if value is not None: print ' %s = %s;' % (src_channel.name, value) - shift += src_channel.size - # Convert, swizzle, and store final values for i in range(4): - swizzle = format.swizzles[i] + swizzle = swizzles[i] if swizzle < 4: - src_channel = format.channels[swizzle] + src_channel = channels[swizzle] src_colorspace = format.colorspace if src_colorspace == SRGB and i == 3: # Alpha channel is linear @@ -458,15 +505,14 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type): assert False print ' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i]) - else: + def unpack_from_union(channels, swizzles): print ' union util_format_%s pixel;' % format.short_name() print ' memcpy(&pixel, src, sizeof pixel);' - bswap_format(format) for i in range(4): - swizzle = format.swizzles[i] + swizzle = swizzles[i] if swizzle < 4: - src_channel = format.channels[swizzle] + src_channel = channels[swizzle] src_colorspace = format.colorspace if src_colorspace == SRGB and i == 3: # Alpha channel is linear @@ -486,6 +532,11 @@ def generate_unpack_kernel(format, dst_channel, dst_native_type): assert False print ' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i]) + if format.is_bitmask(): + print_channels(format, unpack_from_bitmask) + else: + print_channels(format, unpack_from_union) + def generate_pack_kernel(format, src_channel, src_native_type): @@ -496,15 +547,15 @@ def generate_pack_kernel(format, src_channel, src_native_type): assert format.layout == PLAIN - inv_swizzle = format.inv_swizzles() + def pack_into_bitmask(channels, swizzles): + inv_swizzle = inv_swizzles(swizzles) - if format.is_bitmask(): depth = format.block_size() print ' uint%u_t value = 0;' % depth - shift = 0 for i in range(4): - dst_channel = format.channels[i] + dst_channel = channels[i] + shift = dst_channel.shift if inv_swizzle[i] is not None: value ='src[%u]' % inv_swizzle[i] dst_colorspace = format.colorspace @@ -528,20 +579,15 @@ def generate_pack_kernel(format, src_channel, src_native_type): if value is not None: print ' value |= %s;' % (value) - shift += dst_channel.size - - if depth > 8: - print '#ifdef PIPE_ARCH_BIG_ENDIAN' - print ' value = util_bswap%u(value);' % depth - print '#endif' - print ' *(uint%u_t *)dst = value;' % depth - else: + def pack_into_union(channels, swizzles): + inv_swizzle = inv_swizzles(swizzles) + print ' union util_format_%s pixel;' % format.short_name() for i in range(4): - dst_channel = format.channels[i] + dst_channel = channels[i] width = dst_channel.size if inv_swizzle[i] is None: continue @@ -556,16 +602,20 @@ def generate_pack_kernel(format, src_channel, src_native_type): dst_colorspace = dst_colorspace) print ' pixel.chan.%s = %s;' % (dst_channel.name, value) - bswap_format(format) print ' memcpy(dst, &pixel, sizeof pixel);' + if format.is_bitmask(): + print_channels(format, pack_into_bitmask) + else: + print_channels(format, pack_into_union) + def generate_format_unpack(format, dst_channel, dst_native_type, dst_suffix): '''Generate the function to unpack pixels from a particular format''' name = format.short_name() - print 'static INLINE void' + print 'static inline void' 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_native_type) print '{' @@ -594,7 +644,7 @@ def generate_format_pack(format, src_channel, src_native_type, src_suffix): name = format.short_name() - print 'static INLINE void' + print 'static inline void' 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) print '{' @@ -623,7 +673,7 @@ def generate_format_fetch(format, dst_channel, dst_native_type, dst_suffix): name = format.short_name() - print 'static INLINE void' + print 'static inline void' print 'util_format_%s_fetch_%s(%s *dst, const uint8_t *src, unsigned i, unsigned j)' % (name, dst_suffix, dst_native_type) print '{' @@ -635,7 +685,7 @@ def generate_format_fetch(format, dst_channel, dst_native_type, dst_suffix): def is_format_hand_written(format): - return format.layout in ('s3tc', 'subsampled', 'other') or format.colorspace == ZS + return format.layout in ('s3tc', 'rgtc', 'etc', 'bptc', 'astc', 'subsampled', 'other') or format.colorspace == ZS def generate(formats): @@ -645,7 +695,7 @@ def generate(formats): print '#include "u_half.h"' print '#include "u_format.h"' print '#include "u_format_other.h"' - print '#include "u_format_srgb.h"' + print '#include "util/format_srgb.h"' print '#include "u_format_yuv.h"' print '#include "u_format_zs.h"' print @@ -656,18 +706,47 @@ def generate(formats): if is_format_supported(format): generate_format_type(format) - channel = Channel(FLOAT, False, 32) - native_type = 'float' - suffix = 'rgba_float' + if format.is_pure_unsigned(): + native_type = 'unsigned' + suffix = 'unsigned' + channel = Channel(UNSIGNED, False, True, 32) + + generate_format_unpack(format, channel, native_type, suffix) + generate_format_pack(format, channel, native_type, suffix) + generate_format_fetch(format, channel, native_type, suffix) + + channel = Channel(SIGNED, False, True, 32) + native_type = 'int' + suffix = 'signed' + generate_format_unpack(format, channel, native_type, suffix) + generate_format_pack(format, channel, native_type, suffix) + elif format.is_pure_signed(): + native_type = 'int' + suffix = 'signed' + channel = Channel(SIGNED, False, True, 32) + + generate_format_unpack(format, channel, native_type, suffix) + generate_format_pack(format, channel, native_type, suffix) + generate_format_fetch(format, channel, native_type, suffix) + + native_type = 'unsigned' + suffix = 'unsigned' + channel = Channel(UNSIGNED, False, True, 32) + generate_format_unpack(format, channel, native_type, suffix) + generate_format_pack(format, channel, native_type, suffix) + else: + channel = Channel(FLOAT, False, False, 32) + native_type = 'float' + suffix = 'rgba_float' - generate_format_unpack(format, channel, native_type, suffix) - generate_format_pack(format, channel, native_type, suffix) - generate_format_fetch(format, channel, native_type, suffix) + generate_format_unpack(format, channel, native_type, suffix) + generate_format_pack(format, channel, native_type, suffix) + generate_format_fetch(format, channel, native_type, suffix) - channel = Channel(UNSIGNED, True, 8) - native_type = 'uint8_t' - suffix = 'rgba_8unorm' + channel = Channel(UNSIGNED, True, False, 8) + native_type = 'uint8_t' + suffix = 'rgba_8unorm' - generate_format_unpack(format, channel, native_type, suffix) - generate_format_pack(format, channel, native_type, suffix) + generate_format_unpack(format, channel, native_type, suffix) + generate_format_pack(format, channel, native_type, suffix)