-#!/usr/bin/env python
'''
/**************************************************************************
'''
+from __future__ import division, print_function
+
import sys
-import math
from u_format_parse import *
+if sys.version_info < (3, 0):
+ integer_types = (int, long)
+
+else:
+ integer_types = (int, )
+
+
+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)
+ print(' unsigned %s:%u;' % (channel.name, channel.size))
elif channel.type == UNSIGNED:
- print ' unsigned %s:%u;' % (channel.name, channel.size)
+ print(' unsigned %s:%u;' % (channel.name, channel.size))
elif channel.type in (SIGNED, FIXED):
- print ' int %s:%u;' % (channel.name, channel.size)
+ print(' int %s:%u;' % (channel.name, channel.size))
elif channel.type == FLOAT:
if channel.size == 64:
- print ' double %s;' % (channel.name)
+ print(' double %s;' % (channel.name))
elif channel.size == 32:
- print ' float %s;' % (channel.name)
+ print(' float %s;' % (channel.name))
else:
- print ' unsigned %s:%u;' % (channel.name, channel.size)
+ 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:
- print ' uint%u_t %s;' % (channel.size, channel.name)
+ print(' uint%u_t %s;' % (channel.size, channel.name))
elif channel.type == UNSIGNED:
- print ' uint%u_t %s;' % (channel.size, channel.name)
+ print(' uint%u_t %s;' % (channel.size, channel.name))
elif channel.type in (SIGNED, FIXED):
- print ' int%u_t %s;' % (channel.size, channel.name)
+ print(' int%u_t %s;' % (channel.size, channel.name))
elif channel.type == FLOAT:
if channel.size == 64:
- print ' double %s;' % (channel.name)
+ print(' double %s;' % (channel.name))
elif channel.size == 32:
- print ' float %s;' % (channel.name)
+ print(' float %s;' % (channel.name))
elif channel.size == 16:
- print ' uint16_t %s;' % (channel.name)
+ print(' uint16_t %s;' % (channel.name))
else:
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):
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):
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):
assert False
+def truncate_mantissa(x, bits):
+ '''Truncate an integer so it can be represented exactly with a floating
+ point mantissa'''
+
+ assert isinstance(x, integer_types)
+
+ 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, integer_types):
+ return truncate_mantissa(value, 23)
return value
if type.type == FIXED:
- return int(value * (1 << (type.size/2)))
+ return int(value * (1 << (type.size // 2)))
if not type.norm:
return int(value)
if type.type == UNSIGNED:
'''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))
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)
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:
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:
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:
value = 'util_half_to_float(%s)' % value
src_size = 32
+ # Special case for float <-> ubytes for more accurate results
+ # Done before clamping since these functions already take care of that
+ if src_type == UNSIGNED and src_norm and src_size == 8 and dst_channel.type == FLOAT and dst_channel.size == 32:
+ return 'ubyte_to_float(%s)' % value
+ if src_type == FLOAT and src_size == 32 and dst_channel.type == UNSIGNED and dst_channel.norm and dst_channel.size == 8:
+ return 'float_to_ubyte(%s)' % value
+
if clamp:
if dst_channel.type != FLOAT or src_type != FLOAT:
value = clamp_expr(src_channel, dst_channel, dst_native_type, value)
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)
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)
+ 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)
+ 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'
+ print(' int%u_t %s;' % (depth, src_channel.name))
# 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)
value = None
if value is not None:
- print ' %s = %s;' % (src_channel.name, value)
+ 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
value = '0'
else:
assert False
- print ' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])
+ print(' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i]))
- else:
- print ' union util_format_%s pixel;' % format.short_name()
- print ' memcpy(&pixel, src, sizeof pixel);'
- bswap_format(format)
+ def unpack_from_union(channels, swizzles):
+ print(' union util_format_%s pixel;' % format.short_name())
+ print(' memcpy(&pixel, src, sizeof pixel);')
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
value = '0'
else:
assert False
- print ' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])
+ 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):
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
+ 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
else:
value = None
if value is not None:
- print ' value |= %s;' % (value)
+ print(' value |= %s;' % (value))
- shift += dst_channel.size
+ print(' *(uint%u_t *)dst = value;' % depth)
- 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
+ def pack_into_union(channels, swizzles):
+ inv_swizzle = inv_swizzles(swizzles)
- else:
- print ' union util_format_%s pixel;' % format.short_name()
+ 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
dst_channel, dst_native_type,
value,
dst_colorspace = dst_colorspace)
- print ' pixel.chan.%s = %s;' % (dst_channel.name, value)
+ print(' pixel.chan.%s = %s;' % (dst_channel.name, value))
- bswap_format(format)
- print ' memcpy(dst, &pixel, sizeof pixel);'
+ 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 '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 '{'
+ 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('{')
if is_format_supported(format):
- print ' unsigned x, y;'
- print ' for(y = 0; y < height; y += %u) {' % (format.block_height,)
- print ' %s *dst = dst_row;' % (dst_native_type)
- print ' const uint8_t *src = src_row;'
- print ' for(x = 0; x < width; x += %u) {' % (format.block_width,)
+ print(' unsigned x, y;')
+ print(' for(y = 0; y < height; y += %u) {' % (format.block_height,))
+ print(' %s *dst = dst_row;' % (dst_native_type))
+ print(' const uint8_t *src = src_row;')
+ print(' for(x = 0; x < width; x += %u) {' % (format.block_width,))
generate_unpack_kernel(format, dst_channel, dst_native_type)
- print ' src += %u;' % (format.block_size() / 8,)
- print ' dst += 4;'
- print ' }'
- print ' src_row += src_stride;'
- print ' dst_row += dst_stride/sizeof(*dst_row);'
- print ' }'
-
- print '}'
- print
+ print(' src += %u;' % (format.block_size() / 8,))
+ print(' dst += 4;')
+ print(' }')
+ print(' src_row += src_stride;')
+ print(' dst_row += dst_stride/sizeof(*dst_row);')
+ print(' }')
+
+ print('}')
+ print()
def generate_format_pack(format, src_channel, src_native_type, src_suffix):
name = format.short_name()
- 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 '{'
+ 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('{')
if is_format_supported(format):
- print ' unsigned x, y;'
- print ' for(y = 0; y < height; y += %u) {' % (format.block_height,)
- print ' const %s *src = src_row;' % (src_native_type)
- print ' uint8_t *dst = dst_row;'
- print ' for(x = 0; x < width; x += %u) {' % (format.block_width,)
+ print(' unsigned x, y;')
+ print(' for(y = 0; y < height; y += %u) {' % (format.block_height,))
+ print(' const %s *src = src_row;' % (src_native_type))
+ print(' uint8_t *dst = dst_row;')
+ print(' for(x = 0; x < width; x += %u) {' % (format.block_width,))
generate_pack_kernel(format, src_channel, src_native_type)
- print ' src += 4;'
- print ' dst += %u;' % (format.block_size() / 8,)
- print ' }'
- print ' dst_row += dst_stride;'
- print ' src_row += src_stride/sizeof(*src_row);'
- print ' }'
+ print(' src += 4;')
+ print(' dst += %u;' % (format.block_size() / 8,))
+ print(' }')
+ print(' dst_row += dst_stride;')
+ print(' src_row += src_stride/sizeof(*src_row);')
+ print(' }')
- print '}'
- print
+ print('}')
+ print()
def generate_format_fetch(format, dst_channel, dst_native_type, dst_suffix):
name = format.short_name()
- 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 '{'
+ print('static inline void')
+ print('util_format_%s_fetch_%s(%s *dst, const uint8_t *src, UNUSED unsigned i, UNUSED unsigned j)' % (name, dst_suffix, dst_native_type))
+ print('{')
if is_format_supported(format):
generate_unpack_kernel(format, dst_channel, dst_native_type)
- print '}'
- print
+ print('}')
+ print()
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):
- print
- print '#include "pipe/p_compiler.h"'
- print '#include "u_math.h"'
- print '#include "u_half.h"'
- print '#include "u_format.h"'
- print '#include "u_format_other.h"'
- print '#include "u_format_srgb.h"'
- print '#include "u_format_yuv.h"'
- print '#include "u_format_zs.h"'
- print
+ print()
+ print('#include "pipe/p_compiler.h"')
+ print('#include "util/u_math.h"')
+ print('#include "u_half.h"')
+ print('#include "u_format.h"')
+ print('#include "u_format_other.h"')
+ print('#include "util/format_srgb.h"')
+ print('#include "u_format_yuv.h"')
+ print('#include "u_format_zs.h"')
+ print()
for format in formats:
if not is_format_hand_written(format):
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)
projects / mesa.git / blobdiff