753 lines
27 KiB
Python
753 lines
27 KiB
Python
|
|
'''
|
|
/**************************************************************************
|
|
*
|
|
* Copyright 2009-2010 VMware, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
**************************************************************************/
|
|
|
|
/**
|
|
* @file
|
|
* Pixel format packing and unpacking functions.
|
|
*
|
|
* @author Jose Fonseca <jfonseca@vmware.com>
|
|
*/
|
|
'''
|
|
|
|
import sys
|
|
|
|
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:
|
|
if (format.le_channels == format.be_channels and
|
|
[c.shift for c in format.le_channels] ==
|
|
[c.shift for c in format.be_channels] and
|
|
format.le_swizzles == format.be_swizzles):
|
|
func(format.le_channels, format.le_swizzles)
|
|
else:
|
|
print('#if UTIL_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
|
|
|
|
def generate_bitfields(channels, swizzles):
|
|
for channel in channels:
|
|
if channel.type == VOID:
|
|
if channel.size:
|
|
print(' unsigned %s:%u;' % (channel.name, channel.size))
|
|
elif channel.type == UNSIGNED:
|
|
print(' unsigned %s:%u;' % (channel.name, channel.size))
|
|
elif channel.type in (SIGNED, FIXED):
|
|
print(' int %s:%u;' % (channel.name, channel.size))
|
|
elif channel.type == FLOAT:
|
|
if channel.size == 64:
|
|
print(' double %s;' % (channel.name))
|
|
elif channel.size == 32:
|
|
print(' float %s;' % (channel.name))
|
|
else:
|
|
print(' unsigned %s:%u;' % (channel.name, channel.size))
|
|
else:
|
|
assert 0
|
|
|
|
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))
|
|
elif channel.type == UNSIGNED:
|
|
print(' uint%u_t %s;' % (channel.size, channel.name))
|
|
elif channel.type in (SIGNED, FIXED):
|
|
print(' int%u_t %s;' % (channel.size, channel.name))
|
|
elif channel.type == FLOAT:
|
|
if channel.size == 64:
|
|
print(' double %s;' % (channel.name))
|
|
elif channel.size == 32:
|
|
print(' float %s;' % (channel.name))
|
|
elif channel.size == 16:
|
|
print(' uint16_t %s;' % (channel.name))
|
|
else:
|
|
assert 0
|
|
else:
|
|
assert 0
|
|
|
|
use_bitfields = False
|
|
for channel in format.le_channels:
|
|
if channel.size % 8 or not is_pot(channel.size):
|
|
use_bitfields = True
|
|
|
|
print('struct util_format_%s {' % format.short_name())
|
|
if use_bitfields:
|
|
print_channels(format, generate_bitfields)
|
|
else:
|
|
print_channels(format, generate_full_fields)
|
|
print('};')
|
|
print()
|
|
|
|
|
|
def is_format_supported(format):
|
|
'''Determines whether we actually have the plumbing necessary to generate the
|
|
to read/write to/from this format.'''
|
|
|
|
# FIXME: Ideally we would support any format combination here.
|
|
|
|
if format.layout != PLAIN:
|
|
return False
|
|
|
|
for i in range(4):
|
|
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 False
|
|
|
|
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.array_element()
|
|
if channel.type in (UNSIGNED, VOID):
|
|
return 'uint%u_t' % channel.size
|
|
elif channel.type in (SIGNED, FIXED):
|
|
return 'int%u_t' % channel.size
|
|
elif channel.type == FLOAT:
|
|
if channel.size == 16:
|
|
return 'uint16_t'
|
|
elif channel.size == 32:
|
|
return 'float'
|
|
elif channel.size == 64:
|
|
return 'double'
|
|
else:
|
|
assert False
|
|
else:
|
|
assert False
|
|
else:
|
|
assert False
|
|
|
|
|
|
def intermediate_native_type(bits, sign):
|
|
'''Find a native type adequate to hold intermediate results of the request bit size.'''
|
|
|
|
bytes = 4 # don't use anything smaller than 32bits
|
|
while bytes * 8 < bits:
|
|
bytes *= 2
|
|
bits = bytes*8
|
|
|
|
if sign:
|
|
return 'int%u_t' % bits
|
|
else:
|
|
return 'uint%u_t' % bits
|
|
|
|
|
|
def get_one_shift(type):
|
|
'''Get the number of the bit that matches unity for this type.'''
|
|
if type.type == 'FLOAT':
|
|
assert False
|
|
if not type.norm:
|
|
return 0
|
|
if type.type == UNSIGNED:
|
|
return type.size
|
|
if type.type == SIGNED:
|
|
return type.size - 1
|
|
if type.type == FIXED:
|
|
return type.size / 2
|
|
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)
|
|
|
|
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):
|
|
return truncate_mantissa(value, 23)
|
|
return value
|
|
if type.type == FIXED:
|
|
return int(value * (1 << (type.size // 2)))
|
|
if not type.norm:
|
|
return int(value)
|
|
if type.type == UNSIGNED:
|
|
return int(value * ((1 << type.size) - 1))
|
|
if type.type == SIGNED:
|
|
return int(value * ((1 << (type.size - 1)) - 1))
|
|
assert False
|
|
|
|
|
|
def native_to_constant(type, value):
|
|
'''Get the value of unity for this type.'''
|
|
if type.type == FLOAT:
|
|
if type.size <= 32:
|
|
return "%.1ff" % float(value)
|
|
else:
|
|
return "%.1f" % float(value)
|
|
else:
|
|
return str(int(value))
|
|
|
|
|
|
def get_one(type):
|
|
'''Get the value of unity for this type.'''
|
|
return value_to_native(type, 1)
|
|
|
|
|
|
def clamp_expr(src_channel, dst_channel, dst_native_type, value):
|
|
'''Generate the expression to clamp the value in the source type to the
|
|
destination type range.'''
|
|
|
|
if src_channel == dst_channel:
|
|
return value
|
|
|
|
src_min = src_channel.min()
|
|
src_max = src_channel.max()
|
|
dst_min = dst_channel.min()
|
|
dst_max = dst_channel.max()
|
|
|
|
# Translate the destination range to the src native value
|
|
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_max > dst_max:
|
|
return 'MIN2(%s, %s)' % (value, dst_max_native)
|
|
|
|
if src_min < dst_min:
|
|
return 'MAX2(%s, %s)' % (value, dst_min_native)
|
|
|
|
return value
|
|
|
|
|
|
def conversion_expr(src_channel,
|
|
dst_channel, dst_native_type,
|
|
value,
|
|
clamp=True,
|
|
src_colorspace = RGB,
|
|
dst_colorspace = RGB):
|
|
'''Generate the expression to convert a value between two types.'''
|
|
|
|
if src_colorspace != dst_colorspace:
|
|
if src_colorspace == SRGB:
|
|
assert src_channel.type == UNSIGNED
|
|
assert src_channel.norm
|
|
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:
|
|
assert dst_channel.type == UNSIGNED
|
|
assert dst_channel.norm
|
|
assert dst_channel.size == 8
|
|
return 'util_format_srgb_to_linear_8unorm(%s)' % value
|
|
elif dst_colorspace == SRGB:
|
|
assert dst_channel.type == UNSIGNED
|
|
assert dst_channel.norm
|
|
assert dst_channel.size <= 8
|
|
assert src_colorspace == RGB
|
|
if src_channel.type == FLOAT:
|
|
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
|
|
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:
|
|
pass
|
|
else:
|
|
assert 0
|
|
|
|
if src_channel == dst_channel:
|
|
return value
|
|
|
|
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 = '_mesa_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 src_type in (SIGNED, UNSIGNED) and dst_channel.type in (SIGNED, UNSIGNED):
|
|
if not src_norm and not dst_channel.norm:
|
|
# neither is normalized -- just cast
|
|
return '(%s)%s' % (dst_native_type, value)
|
|
|
|
if src_norm and dst_channel.norm:
|
|
return "_mesa_%snorm_to_%snorm(%s, %d, %d)" % ("s" if src_type == SIGNED else "u",
|
|
"s" if dst_channel.type == SIGNED else "u",
|
|
value, src_channel.size, dst_channel.size)
|
|
else:
|
|
# We need to rescale using an intermediate type big enough to hold the multiplication of both
|
|
src_one = get_one(src_channel)
|
|
dst_one = get_one(dst_channel)
|
|
tmp_native_type = intermediate_native_type(src_size + dst_channel.size, src_channel.sign and dst_channel.sign)
|
|
value = '((%s)%s)' % (tmp_native_type, value)
|
|
value = '(%s)(%s * 0x%x / 0x%x)' % (dst_native_type, value, dst_one, src_one)
|
|
return value
|
|
|
|
|
|
# Promote to either float or double
|
|
if src_type != FLOAT:
|
|
if src_norm or src_type == FIXED:
|
|
one = get_one(src_channel)
|
|
if src_size <= 23:
|
|
value = '(%s * (1.0f/0x%x))' % (value, one)
|
|
if dst_channel.size <= 32:
|
|
value = '(float)%s' % value
|
|
src_size = 32
|
|
else:
|
|
# bigger than single precision mantissa, use double
|
|
value = '(%s * (1.0/0x%x))' % (value, one)
|
|
src_size = 64
|
|
src_norm = False
|
|
else:
|
|
if src_size <= 23 or dst_channel.size <= 32:
|
|
value = '(float)%s' % value
|
|
src_size = 32
|
|
else:
|
|
# bigger than single precision mantissa, use double
|
|
value = '(double)%s' % value
|
|
src_size = 64
|
|
src_type = FLOAT
|
|
|
|
# Convert double or float to non-float
|
|
if dst_channel.type != FLOAT:
|
|
if dst_channel.norm or dst_channel.type == FIXED:
|
|
dst_one = get_one(dst_channel)
|
|
if dst_channel.size <= 23:
|
|
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)
|
|
value = '(%s)%s' % (dst_native_type, value)
|
|
else:
|
|
# Cast double to float when converting to either half or float
|
|
if dst_channel.size <= 32 and src_size > 32:
|
|
value = '(float)%s' % value
|
|
src_size = 32
|
|
|
|
if dst_channel.size == 16:
|
|
value = '_mesa_float_to_float16_rtz(%s)' % value
|
|
elif dst_channel.size == 64 and src_size < 64:
|
|
value = '(double)%s' % value
|
|
|
|
return value
|
|
|
|
|
|
def generate_unpack_kernel(format, dst_channel, dst_native_type):
|
|
|
|
if not is_format_supported(format):
|
|
return
|
|
|
|
assert format.layout == PLAIN
|
|
|
|
def unpack_from_bitmask(channels, swizzles):
|
|
depth = format.block_size()
|
|
print(' uint%u_t value = *(const uint%u_t *)src;' % (depth, depth))
|
|
|
|
# Compute the intermediate unshifted values
|
|
for i in range(format.nr_channels()):
|
|
src_channel = channels[i]
|
|
value = 'value'
|
|
shift = src_channel.shift
|
|
if src_channel.type == UNSIGNED:
|
|
if shift:
|
|
value = '%s >> %u' % (value, shift)
|
|
if shift + src_channel.size < depth:
|
|
value = '(%s) & 0x%x' % (value, (1 << src_channel.size) - 1)
|
|
print(' uint%u_t %s = %s;' % (depth, src_channel.name, value))
|
|
elif src_channel.type == SIGNED:
|
|
if shift + src_channel.size < depth:
|
|
# Align the sign bit
|
|
lshift = depth - (shift + src_channel.size)
|
|
value = '%s << %u' % (value, lshift)
|
|
# Cast to signed
|
|
value = '(int%u_t)(%s) ' % (depth, value)
|
|
if src_channel.size < depth:
|
|
# Align the LSB bit
|
|
rshift = depth - src_channel.size
|
|
value = '(%s) >> %u' % (value, rshift)
|
|
print(' int%u_t %s = %s;' % (depth, src_channel.name, value))
|
|
else:
|
|
value = None
|
|
|
|
# Convert, swizzle, and store final values
|
|
for i in range(4):
|
|
swizzle = swizzles[i]
|
|
if swizzle < 4:
|
|
src_channel = channels[swizzle]
|
|
src_colorspace = format.colorspace
|
|
if src_colorspace == SRGB and i == 3:
|
|
# Alpha channel is linear
|
|
src_colorspace = RGB
|
|
value = src_channel.name
|
|
value = conversion_expr(src_channel,
|
|
dst_channel, dst_native_type,
|
|
value,
|
|
src_colorspace = src_colorspace)
|
|
elif swizzle == SWIZZLE_0:
|
|
value = '0'
|
|
elif swizzle == SWIZZLE_1:
|
|
value = get_one(dst_channel)
|
|
elif swizzle == SWIZZLE_NONE:
|
|
value = '0'
|
|
else:
|
|
assert False
|
|
print(' dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i]))
|
|
|
|
def unpack_from_struct(channels, swizzles):
|
|
print(' struct util_format_%s pixel;' % format.short_name())
|
|
print(' memcpy(&pixel, src, sizeof pixel);')
|
|
|
|
for i in range(4):
|
|
swizzle = swizzles[i]
|
|
if swizzle < 4:
|
|
src_channel = channels[swizzle]
|
|
src_colorspace = format.colorspace
|
|
if src_colorspace == SRGB and i == 3:
|
|
# Alpha channel is linear
|
|
src_colorspace = RGB
|
|
value = 'pixel.%s' % src_channel.name
|
|
value = conversion_expr(src_channel,
|
|
dst_channel, dst_native_type,
|
|
value,
|
|
src_colorspace = src_colorspace)
|
|
elif swizzle == SWIZZLE_0:
|
|
value = '0'
|
|
elif swizzle == SWIZZLE_1:
|
|
value = get_one(dst_channel)
|
|
elif swizzle == SWIZZLE_NONE:
|
|
value = '0'
|
|
else:
|
|
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_struct)
|
|
|
|
|
|
def generate_pack_kernel(format, src_channel, src_native_type):
|
|
|
|
if not is_format_supported(format):
|
|
return
|
|
|
|
dst_native_type = native_type(format)
|
|
|
|
assert format.layout == PLAIN
|
|
|
|
def pack_into_bitmask(channels, swizzles):
|
|
inv_swizzle = inv_swizzles(swizzles)
|
|
|
|
depth = format.block_size()
|
|
print(' uint%u_t value = 0;' % depth)
|
|
|
|
for i in range(4):
|
|
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
|
|
if dst_colorspace == SRGB and inv_swizzle[i] == 3:
|
|
# Alpha channel is linear
|
|
dst_colorspace = RGB
|
|
value = conversion_expr(src_channel,
|
|
dst_channel, dst_native_type,
|
|
value,
|
|
dst_colorspace = dst_colorspace)
|
|
if dst_channel.type in (UNSIGNED, SIGNED):
|
|
if shift + dst_channel.size < depth:
|
|
value = '(%s) & 0x%x' % (value, (1 << dst_channel.size) - 1)
|
|
if shift:
|
|
value = '(uint32_t)(%s) << %u' % (value, shift)
|
|
if dst_channel.type == SIGNED:
|
|
# Cast to unsigned
|
|
value = '(uint%u_t)(%s) ' % (depth, value)
|
|
else:
|
|
value = None
|
|
if value is not None:
|
|
print(' value |= %s;' % (value))
|
|
|
|
print(' *(uint%u_t *)dst = value;' % depth)
|
|
|
|
def pack_into_struct(channels, swizzles):
|
|
inv_swizzle = inv_swizzles(swizzles)
|
|
|
|
print(' struct util_format_%s pixel = {0};' % format.short_name())
|
|
|
|
for i in range(4):
|
|
dst_channel = channels[i]
|
|
width = dst_channel.size
|
|
if inv_swizzle[i] is None:
|
|
continue
|
|
dst_colorspace = format.colorspace
|
|
if dst_colorspace == SRGB and inv_swizzle[i] == 3:
|
|
# Alpha channel is linear
|
|
dst_colorspace = RGB
|
|
value ='src[%u]' % inv_swizzle[i]
|
|
value = conversion_expr(src_channel,
|
|
dst_channel, dst_native_type,
|
|
value,
|
|
dst_colorspace = dst_colorspace)
|
|
print(' pixel.%s = %s;' % (dst_channel.name, value))
|
|
|
|
print(' memcpy(dst, &pixel, sizeof pixel);')
|
|
|
|
if format.is_bitmask():
|
|
print_channels(format, pack_into_bitmask)
|
|
else:
|
|
print_channels(format, pack_into_struct)
|
|
|
|
|
|
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()
|
|
|
|
if "8unorm" in dst_suffix:
|
|
dst_proto_type = dst_native_type
|
|
else:
|
|
dst_proto_type = 'void'
|
|
|
|
proto = 'util_format_%s_unpack_%s(%s *restrict dst_row, const uint8_t *restrict src, unsigned width)' % (
|
|
name, dst_suffix, dst_proto_type)
|
|
print('void %s;' % proto, file=sys.stdout2)
|
|
|
|
print('void')
|
|
print(proto)
|
|
print('{')
|
|
|
|
if is_format_supported(format):
|
|
print(' %s *dst = dst_row;' % (dst_native_type))
|
|
print(
|
|
' for (unsigned 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('}')
|
|
print()
|
|
|
|
|
|
def generate_format_pack(format, src_channel, src_native_type, src_suffix):
|
|
'''Generate the function to pack pixels to a particular format'''
|
|
|
|
name = format.short_name()
|
|
|
|
print('void')
|
|
print('util_format_%s_pack_%s(uint8_t *restrict dst_row, unsigned dst_stride, const %s *restrict src_row, unsigned src_stride, unsigned width, unsigned height)' %
|
|
(name, src_suffix, src_native_type))
|
|
print('{')
|
|
|
|
print('void util_format_%s_pack_%s(uint8_t *restrict dst_row, unsigned dst_stride, const %s *restrict src_row, unsigned src_stride, unsigned width, unsigned height);' %
|
|
(name, src_suffix, src_native_type), file=sys.stdout2)
|
|
|
|
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,))
|
|
|
|
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('}')
|
|
print()
|
|
|
|
|
|
def generate_format_fetch(format, dst_channel, dst_native_type):
|
|
'''Generate the function to unpack pixels from a particular format'''
|
|
|
|
name = format.short_name()
|
|
|
|
proto = 'util_format_%s_fetch_rgba(void *restrict in_dst, const uint8_t *restrict src, UNUSED unsigned i, UNUSED unsigned j)' % (name)
|
|
print('void %s;' % proto, file=sys.stdout2)
|
|
|
|
print('void')
|
|
print(proto)
|
|
|
|
print('{')
|
|
print(' %s *dst = in_dst;' % dst_native_type)
|
|
|
|
if is_format_supported(format):
|
|
generate_unpack_kernel(format, dst_channel, dst_native_type)
|
|
|
|
print('}')
|
|
print()
|
|
|
|
|
|
def is_format_hand_written(format):
|
|
return format.layout != PLAIN or format.colorspace == ZS
|
|
|
|
|
|
def generate(formats):
|
|
print()
|
|
print('#include "pipe/p_compiler.h"')
|
|
print('#include "util/u_math.h"')
|
|
print('#include "util/half_float.h"')
|
|
print('#include "u_format.h"')
|
|
print('#include "u_format_other.h"')
|
|
print('#include "util/format_srgb.h"')
|
|
print('#include "format_utils.h"')
|
|
print('#include "u_format_yuv.h"')
|
|
print('#include "u_format_zs.h"')
|
|
print('#include "u_format_pack.h"')
|
|
print()
|
|
|
|
for format in formats:
|
|
if not is_format_hand_written(format):
|
|
|
|
if is_format_supported(format) and not format.is_bitmask():
|
|
generate_format_type(format)
|
|
|
|
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)
|
|
|
|
channel = Channel(SIGNED, False, True, 32)
|
|
native_type = 'int'
|
|
suffix = 'signed'
|
|
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)
|
|
|
|
native_type = 'unsigned'
|
|
suffix = 'unsigned'
|
|
channel = Channel(UNSIGNED, False, True, 32)
|
|
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)
|
|
|
|
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)
|