path: root/src/gallium/auxiliary/util/u_format_pack.py

#!/usr/bin/env python

'''
/**************************************************************************
 *
 * Copyright 2009 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 generate_format_type(format):
    '''Generate a structure that describes the format.'''

    print 'union util_format_%s {' % format.short_name()
    if format.is_bitmask():
        print '   uint%u_t value;' % (format.block_size(),)
    print '   struct {'
    for channel in format.channels:
        if format.is_bitmask() and not format.is_array():
            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 == SIGNED:
                print '      int %s:%u;' % (channel.name, channel.size)
            else:
                assert 0
        else:
            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
    print '   } chan;'
    print '};'
    print


def bswap_format(format):
    '''Generate a structure that describes the format.'''

    if format.is_bitmask() and not format.is_array():
        print '#ifdef PIPE_ARCH_BIG_ENDIAN'
        print '   pixel.value = util_bswap%u(pixel.value);' % format.block_size()
        print '#endif'


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.channels[i]
        if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT):
            return False

    # We can only read a color from a depth/stencil format if the depth channel is present
    if format.colorspace == 'zs' and format.swizzles[0] == SWIZZLE_NONE:
        return False

    return True


def native_type(format):
    '''Get the native appropriate for a format.'''

    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
            type = format.channels[0]
            if type.type == UNSIGNED:
                return 'uint%u_t' % type.size
            elif type.type == SIGNED:
                return 'int%u_t' % type.size
            elif type.type == FLOAT:
                if type.size == 32:
                    return 'float'
                elif type.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 get_one(type):
    '''Get the value of unity for this type.'''
    if type.type == 'FLOAT' or not type.norm:
        return 1
    else:
        return (1 << get_one_shift(type)) - 1


def generate_clamp():
    '''Code generate the clamping functions for each type.

    We don't use a macro so that arguments with side effects, 
    like *src_pixel++ are correctly handled.
    '''

    for suffix, native_type in [
        ('', 'double'),
        ('f', 'float'),
        ('ui', 'unsigned int'),
        ('si', 'int'),
    ]:
        print 'static INLINE %s' % native_type
        print 'clamp%s(%s value, %s lbound, %s ubound)' % (suffix, native_type, native_type, native_type)
        print '{'
        print '   if(value < lbound)'
        print '      return lbound;'
        print '   if(value > ubound)'
        print '      return ubound;'
        print '   return value;'
        print '}'
        print


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

    # Pick the approriate clamp function
    if src_channel.type == FLOAT:
        if src_channel.size == 32:
            func = 'clampf'
        elif src_channel.size == 64:
            func = 'clamp'
        else:
            assert False
    elif src_channel.type == UNSIGNED:
        func = 'clampui'
    elif src_channel.type == SIGNED:
        func = 'clampsi'
    else:
        assert False

    src_min = src_channel.min()
    src_max = src_channel.max()
    dst_min = dst_channel.min()
    dst_max = dst_channel.max()

    if src_min < dst_min and src_max > dst_max:
        return 'CLAMP(%s, %s, %s)' % (value, dst_min, dst_max)

    if src_max > dst_max:
        return 'MIN2(%s, %s)' % (value, dst_max)
        
    if src_min < dst_min:
        return 'MAX2(%s, %s)' % (value, dst_min)

    return value


def conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=True):
    '''Generate the expression to convert a value between two types.'''

    if src_channel == dst_channel:
        return value

    if src_channel.type == FLOAT and dst_channel.type == FLOAT:
        return '(%s)%s' % (dst_native_type, value)
    
    if clamp:
        value = clamp_expr(src_channel, dst_channel, dst_native_type, value)

    if dst_channel.type == FLOAT:
        if src_channel.norm:
            one = get_one(src_channel)
            if src_channel.size <= 23:
                scale = '(1.0f/0x%x)' % one
            else:
                # bigger than single precision mantissa, use double
                scale = '(1.0/0x%x)' % one
            value = '(%s * %s)' % (value, scale)
        return '(%s)%s' % (dst_native_type, value)

    if src_channel.type == FLOAT:
        if dst_channel.norm:
            dst_one = get_one(dst_channel)
            if dst_channel.size <= 23:
                scale = '0x%x' % dst_one
            else:
                # bigger than single precision mantissa, use double
                scale = '(double)0x%x' % dst_one
            value = '(%s * %s)' % (value, scale)
        return '(%s)%s' % (dst_native_type, value)

    if src_channel.type in (SIGNED, UNSIGNED) and dst_channel.type in (SIGNED, UNSIGNED):
        if not src_channel.norm and not dst_channel.norm:
            # neither is normalized -- just cast
            return '(%s)%s' % (dst_native_type, value)

        src_one = get_one(src_channel)
        dst_one = get_one(dst_channel)

        if src_one > dst_one and src_channel.norm and dst_channel.norm:
            # We can just bitshift
            src_shift = get_one_shift(src_channel)
            dst_shift = get_one_shift(dst_channel)
            value = '(%s >> %s)' % (value, src_shift - dst_shift)
        else:
            # We need to rescale using an intermediate type big enough to hold the multiplication of both
            tmp_native_type = intermediate_native_type(src_channel.size + dst_channel.size, src_channel.sign and dst_channel.sign)
            value = '((%s)%s)' % (tmp_native_type, value)
            value = '(%s * 0x%x / 0x%x)' % (value, dst_one, src_one)
        value = '(%s)%s' % (dst_native_type, value)
        return value

    assert False


def generate_format_unpack(format, dst_channel, dst_native_type, dst_suffix):
    '''Generate the function to unpack pixels from a particular format'''

    assert format.layout == PLAIN

    name = format.short_name()

    src_native_type = native_type(format)

    print 'static INLINE void'
    print 'util_format_%s_unpack_%s(%s *dst, const void *src)' % (name, dst_suffix, dst_native_type)
    print '{'
    
    if format.is_bitmask():
        depth = format.block_size()
        print '   uint%u_t value = *(uint%u_t *)src;' % (depth, depth) 

        # Declare the intermediate variables
        for i in range(format.nr_channels()):
            src_channel = format.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)

        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]
            value = 'value'
            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)
            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)
            else:
                value = None
                
            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]
            if swizzle < 4:
                src_channel = format.channels[swizzle]
                value = src_channel.name 
                value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
            elif swizzle == SWIZZLE_0:
                value = '0'
            elif swizzle == SWIZZLE_1:
                value = get_one(dst_channel)
            elif swizzle == SWIZZLE_NONE:
                value = '0'
            else:
                assert False
            if format.colorspace == ZS:
                if i == 3:
                    value = get_one(dst_channel)
                elif i >= 1:
                    value = 'dst[0]'
            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)
    
        for i in range(4):
            swizzle = format.swizzles[i]
            if swizzle < 4:
                src_channel = format.channels[swizzle]
                value = 'pixel.chan.%s' % src_channel.name 
                value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
            elif swizzle == SWIZZLE_0:
                value = '0'
            elif swizzle == SWIZZLE_1:
                value = get_one(dst_channel)
            elif swizzle == SWIZZLE_NONE:
                value = '0'
            else:
                assert False
            if format.colorspace == ZS:
                if i == 3:
                    value = get_one(dst_channel)
                elif i >= 1:
                    value = 'dst[0]'
            print '   dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])

    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()

    dst_native_type = native_type(format)

    assert format.layout == PLAIN

    inv_swizzle = format.inv_swizzles()
    
    print 'static INLINE void'
    print 'util_format_%s_pack_%s(void *dst, %s r, %s g, %s b, %s a)' % (name, src_suffix, src_native_type, src_native_type, src_native_type, src_native_type)
    print '{'
    
    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]
            if inv_swizzle[i] is not None:
                value = 'rgba'[inv_swizzle[i]]
                value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
                if format.colorspace == ZS:
                    if i == 3:
                        value = get_one(dst_channel)
                    elif i >= 1:
                        value = '0'
                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 = '(%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)
                
            shift += dst_channel.size

        print '#ifdef PIPE_ARCH_BIG_ENDIAN'
        print '   value = util_bswap%u(value);' % depth
        print '#endif'
        
        print '   *(uint%u_t *)dst = value;' % depth 

    else:
        print '   union util_format_%s pixel;' % format.short_name()
    
        for i in range(4):
            dst_channel = format.channels[i]
            width = dst_channel.size
            if inv_swizzle[i] is None:
                continue
            value = 'rgba'[inv_swizzle[i]]
            value = conversion_expr(src_channel, dst_channel, dst_native_type, value)
            if format.colorspace == ZS:
                if i == 3:
                    value = get_one(dst_channel)
                elif i >= 1:
                    value = '0'
            print '   pixel.chan.%s = %s;' % (dst_channel.name, value)
    
        bswap_format(format)
        print '   memcpy(dst, &pixel, sizeof pixel);'
        
    print '}'
    print
    

def generate_unpack(formats, dst_channel, dst_native_type, dst_suffix):
    '''Generate the dispatch function to unpack pixels from any format'''

    for format in formats:
        if is_format_supported(format):
            generate_format_unpack(format, dst_channel, dst_native_type, dst_suffix)

    print 'static INLINE void'
    print 'util_format_unpack_%s(enum pipe_format format, %s *dst, const void *src)' % (dst_suffix, dst_native_type)
    print '{'
    print '   void (*func)(%s *dst, const void *src);' % dst_native_type
    print '   switch(format) {'
    for format in formats:
        if is_format_supported(format):
            print '   case %s:' % format.name
            print '      func = &util_format_%s_unpack_%s;' % (format.short_name(), dst_suffix)
            print '      break;'
    print '   default:'
    print '      debug_printf("unsupported format\\n");'
    print '      return;'
    print '   }'
    print '   func(dst, src);'
    print '}'
    print


def generate_pack(formats, src_channel, src_native_type, src_suffix):
    '''Generate the dispatch function to pack pixels to any format'''

    for format in formats:
        if is_format_supported(format):
            generate_format_pack(format, src_channel, src_native_type, src_suffix)

    print 'static INLINE void'
    print 'util_format_pack_%s(enum pipe_format format, void *dst, %s r, %s g, %s b, %s a)' % (src_suffix, src_native_type, src_native_type, src_native_type, src_native_type)
    print '{'
    print '   void (*func)(void *dst, %s r, %s g, %s b, %s a);' % (src_native_type, src_native_type, src_native_type, src_native_type)
    print '   switch(format) {'
    for format in formats:
        if is_format_supported(format):
            print '   case %s:' % format.name
            print '      func = &util_format_%s_pack_%s;' % (format.short_name(), src_suffix)
            print '      break;'
    print '   default:'
    print '      debug_printf("%s: unsupported format\\n", __FUNCTION__);'
    print '      return;'
    print '   }'
    print '   func(dst, r, g, b, a);'
    print '}'
    print


def main():
    formats = []
    for arg in sys.argv[1:]:
        formats.extend(parse(arg))

    print '/* This file is autogenerated by u_format_pack.py from u_format.csv. Do not edit directly. */'
    print
    # This will print the copyright message on the top of this file
    print __doc__.strip()

    print
    print '#ifndef U_FORMAT_PACK_H'
    print '#define U_FORMAT_PACK_H'
    print
    print '#include "pipe/p_compiler.h"'
    print '#include "u_math.h"'
    print '#include "u_format.h"'
    print

    generate_clamp()

    for format in formats:
        if format.layout == PLAIN:
            generate_format_type(format)

    channel = Channel(FLOAT, False, 32)
    native_type = 'float'
    suffix = '4f'

    generate_unpack(formats, channel, native_type, suffix)
    generate_pack(formats, channel, native_type, suffix)

    channel = Channel(UNSIGNED, True, 8)
    native_type = 'uint8_t'
    suffix = '4ub'

    generate_unpack(formats, channel, native_type, suffix)
    generate_pack(formats, channel, native_type, suffix)

    print
    print '#ifdef __cplusplus'
    print '}'
    print '#endif'
    print
    print '#endif /* ! U_FORMAT_PACK_H */'


if __name__ == '__main__':
    main()