Subversion Repositories Kolibri OS

#!/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.

 *

 **************************************************************************/

'''

import sys

VOID, UNSIGNED, SIGNED, FIXED, FLOAT = range(5)

SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_0, SWIZZLE_1, SWIZZLE_NONE, = range(7)

PLAIN = 'plain'

RGB = 'rgb'

SRGB = 'srgb'

YUV = 'yuv'

ZS = 'zs'

# Not cross-compiler friendly

is_big_endian = sys.byteorder == 'big'

def is_pot(x):

   return (x & (x - 1)) == 0

VERY_LARGE = 99999999999999999999999

class Channel:

    '''Describe the channel of a color channel.'''

    def __init__(self, type, norm, pure, size, name = ''):

        self.type = type

        self.norm = norm

        self.pure = pure

        self.size = size

        self.sign = type in (SIGNED, FIXED, FLOAT)

        self.name = name

    def __str__(self):

        s = str(self.type)

        if self.norm:

            s += 'n'

        if self.pure:

            s += 'p'

        s += str(self.size)

        return s

    def __eq__(self, other):

        return self.type == other.type and self.norm == other.norm and self.pure == other.pure and self.size == other.size

    def max(self):

        '''Maximum representable number.'''

        if self.type == FLOAT:

            return VERY_LARGE

        if self.type == FIXED:

            return (1 << (self.size/2)) - 1

        if self.norm:

            return 1

        if self.type == UNSIGNED:

            return (1 << self.size) - 1

        if self.type == SIGNED:

            return (1 << (self.size - 1)) - 1

        assert False

    def min(self):

        '''Minimum representable number.'''

        if self.type == FLOAT:

            return -VERY_LARGE

        if self.type == FIXED:

            return -(1 << (self.size/2))

        if self.type == UNSIGNED:

            return 0

        if self.norm:

            return -1

        if self.type == SIGNED:

            return -(1 << (self.size - 1))

        assert False

class Format:

    '''Describe a pixel format.'''

    def __init__(self, name, layout, block_width, block_height, channels, swizzles, colorspace):

        self.name = name

        self.layout = layout

        self.block_width = block_width

        self.block_height = block_height

        self.channels = channels

        self.swizzles = swizzles

        self.name = name

        self.colorspace = colorspace

    def __str__(self):

        return self.name

    def short_name(self):

        '''Make up a short norm for a format, suitable to be used as suffix in

        function names.'''

        name = self.name

        if name.startswith('PIPE_FORMAT_'):

            name = name[len('PIPE_FORMAT_'):]

        name = name.lower()

        return name

    def block_size(self):

        size = 0

        for channel in self.channels:

            size += channel.size

        return size

    def nr_channels(self):

        nr_channels = 0

        for channel in self.channels:

            if channel.size:

                nr_channels += 1

        return nr_channels

    def is_array(self):

        if self.layout != PLAIN:

            return False

        ref_channel = self.channels[0]

        if ref_channel.type == VOID:

           ref_channel = self.channels[1]

        for channel in self.channels:

            if channel.size and (channel.size != ref_channel.size or channel.size % 8):

                return False

            if channel.type != VOID:

                if channel.type != ref_channel.type:

                    return False

                if channel.norm != ref_channel.norm:

                    return False

                if channel.pure != ref_channel.pure:

                    return False

        return True

    def is_mixed(self):

        if self.layout != PLAIN:

            return False

        ref_channel = self.channels[0]

        if ref_channel.type == VOID:

           ref_channel = self.channels[1]

        for channel in self.channels[1:]:

            if channel.type != VOID:

                if channel.type != ref_channel.type:

                    return True

                if channel.norm != ref_channel.norm:

                    return True

                if channel.pure != ref_channel.pure:

                    return True

        return False

    def is_pot(self):

        return is_pot(self.block_size())

    def is_int(self):

        if self.layout != PLAIN:

            return False

        for channel in self.channels:

            if channel.type not in (VOID, UNSIGNED, SIGNED):

                return False

        return True

    def is_float(self):

        if self.layout != PLAIN:

            return False

        for channel in self.channels:

            if channel.type not in (VOID, FLOAT):

                return False

        return True

    def is_bitmask(self):

        if self.layout != PLAIN:

            return False

        if self.block_size() not in (8, 16, 32):

            return False

        for channel in self.channels:

            if channel.type not in (VOID, UNSIGNED, SIGNED):

                return False

        return True

    def inv_swizzles(self):

        '''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 = self.swizzles[i]

            if swizzle < 4 and inv_swizzle[swizzle] == None:

                inv_swizzle[swizzle] = i

        return inv_swizzle

    def stride(self):

        return self.block_size()/8

_type_parse_map = {

    '':  VOID,

    'x': VOID,

    'u': UNSIGNED,

    's': SIGNED,

    'h': FIXED,

    'f': FLOAT,

}

_swizzle_parse_map = {

    'x': SWIZZLE_X,

    'y': SWIZZLE_Y,

    'z': SWIZZLE_Z,

    'w': SWIZZLE_W,

    '0': SWIZZLE_0,

    '1': SWIZZLE_1,

    '_': SWIZZLE_NONE,

}

def parse(filename):

    '''Parse the format descrition in CSV format in terms of the

    Channel and Format classes above.'''

    stream = open(filename)

    formats = []

    for line in stream:

        try:

            comment = line.index('#')

        except ValueError:

            pass

        else:

            line = line[:comment]

        line = line.strip()

        if not line:

            continue

        fields = [field.strip() for field in line.split(',')]

        name = fields[0]

        layout = fields[1]

        block_width, block_height = map(int, fields[2:4])

        swizzles = [_swizzle_parse_map[swizzle] for swizzle in fields[8]]

        colorspace = fields[9]

        if layout == PLAIN:

            names = ['']*4

            if colorspace in (RGB, SRGB):

                for i in range(4):

                    swizzle = swizzles[i]

                    if swizzle < 4:

                        names[swizzle] += 'rgba'[i]

            elif colorspace == ZS:

                for i in range(4):

                    swizzle = swizzles[i]

                    if swizzle < 4:

                        names[swizzle] += 'zs'[i]

            else:

                assert False

            for i in range(4):

                if names[i] == '':

                    names[i] = 'x'

        else:

            names = ['x', 'y', 'z', 'w']

        channels = []

        for i in range(0, 4):

            field = fields[4 + i]

            if field:

                type = _type_parse_map[field[0]]

                if field[1] == 'n':

                    norm = True

                    pure = False

                    size = int(field[2:])

                elif field[1] == 'p':

                    pure = True

                    norm = False

                    size = int(field[2:])

                else:

                    norm = False

                    pure = False

                    size = int(field[1:])

            else:

                type = VOID

                norm = False

                pure = False

                size = 0

            channel = Channel(type, norm, pure, size, names[i])

            channels.append(channel)

        shift = 0

        for channel in channels[3::-1] if is_big_endian else channels:

            channel.shift = shift

            shift += channel.size

        format = Format(name, layout, block_width, block_height, channels, swizzles, colorspace)

        formats.append(format)

    return formats