<div dir="ltr"> <div class="gmail_extra"> <div class="gmail_quote">On Wed, Dec 3, 2014 at 2:52 PM, Ian Romanick <<a href="mailto:idr@freedesktop.org" target="_blank">idr@freedesktop.org</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="HOEnZb"><div class="h5">On 12/01/2014 03:04 AM, Iago Toral Quiroga wrote: > From: Jason Ekstrand <<a href="mailto:jason.ekstrand@intel.com">jason.ekstrand@intel.com</a>> > > An array format is a 32-bit integer format identifier that can represent > any format that can be represented as an array of standard GL datatypes. > While the MESA_FORMAT enums provide several of these, they don't account > for all of them. > > v2 by Iago Toral Quiroga <<a href="mailto:itoral@igalia.com">itoral@igalia.com</a>>: > - Set pad to 0 and array_format_bit to 1 for all mesa array formats. > - Fix array_format_flip_channels, since it was not doing what was expected. > --- > src/mesa/main/format_info.py | 41 +++++++++++++++++++++++++++++ > src/mesa/main/formats.c | 56 ++++++++++++++++++++++++++++++++++++++- > src/mesa/main/formats.h | 62 ++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 158 insertions(+), 1 deletion(-) > > diff --git a/src/mesa/main/format_info.py b/src/mesa/main/format_info.py > index 7424fe0..315767d 100644 > --- a/src/mesa/main/format_info.py > +++ b/src/mesa/main/format_info.py > @@ -98,6 +98,32 @@ def get_gl_data_type(fmat): > else: > assert False > > +def get_array_format_datatype(chan): > + if chan.type == parser.FLOAT: > + if chan.size == 16: > + return 'MESA_ARRAY_FORMAT_TYPE_HALF' > + elif chan.size == 32: > + return 'MESA_ARRAY_FORMAT_TYPE_FLOAT' > + else: > + assert False > + elif chan.type in (parser.SIGNED, parser.UNSIGNED): > + datatype = 'MESA_ARRAY_FORMAT_TYPE_' > + if chan.type == parser.UNSIGNED: > + datatype += 'U' > + > + if chan.size == 8: > + datatype += 'BYTE' > + elif chan.size == 16: > + datatype += 'SHORT' > + elif chan.size == 32: > + datatype += 'INT' > + else: > + print chan.size > + assert False > + return datatype > + else: > + assert False > + > def get_mesa_layout(fmat): > if fmat.layout == 'array': > return 'MESA_FORMAT_LAYOUT_ARRAY' > @@ -192,6 +218,21 @@ for fmat in formats: > int(fmat.block_size() / 8)) > > print ' {{ {0} }},'.format(', '.join(map(str, fmat.swizzle))) > + if fmat.is_array() and fmat.colorspace in ('rgb', 'srgb'): > + chan = fmat.array_element() > + print ' {{{{ {0} }}}},'.format(', '.join([ > + get_array_format_datatype(chan), > + str(int(chan.norm)), > + str(len(fmat.channels)), > + str(fmat.swizzle[0]), > + str(fmat.swizzle[1]), > + str(fmat.swizzle[2]), > + str(fmat.swizzle[3]), > + str(int(0)), > + str(int(1)) > + ])) > + else: > + print ' {{ MESA_ARRAY_FORMAT_TYPE_UBYTE, 0, 0, 0, 0, 0, 0, 0, 0 }},' > print ' },' > > print '};' > diff --git a/src/mesa/main/formats.c b/src/mesa/main/formats.c > index 7ec0507..f86925e 100644 > --- a/src/mesa/main/formats.c > +++ b/src/mesa/main/formats.c > @@ -71,6 +71,7 @@ struct gl_format_info > GLubyte BytesPerBlock; > > uint8_t Swizzle[4]; > + mesa_array_format ArrayFormat; > }; > > #include "format_info.c" > @@ -269,6 +270,60 @@ _mesa_get_format_swizzle(mesa_format format, uint8_t swizzle_out[4]) > memcpy(swizzle_out, info->Swizzle, sizeof(info->Swizzle)); > } > > +static mesa_array_format > +array_format_flip_channels(mesa_array_format format) > +{ > + if (format.num_channels == 1) > + return format; > + > + if (format.num_channels == 2) { > + int tmp = format.swizzle_x; > + format.swizzle_x = format.swizzle_y; > + format.swizzle_y = tmp; > + return format; > + } > + > + if (format.num_channels == 4) { > + int tmp = format.swizzle_x; > + format.swizzle_x = format.swizzle_w; > + format.swizzle_w = tmp; > + tmp = format.swizzle_y; > + format.swizzle_y = format.swizzle_z; > + format.swizzle_z = tmp; > + return format; > + } > + > + assert(!"Invalid array format"); </div></div>Use unreachable() to prevent warnings in non-debug builds. <div><div class="h5"> > +} > + > +uint32_t > +_mesa_format_to_array_format(mesa_format format) > +{ > + const struct gl_format_info *info = _mesa_get_format_info(format); > + if (_mesa_little_endian()) > + return info->ArrayFormat.as_uint; > + else > + return array_format_flip_channels(info->ArrayFormat).as_uint; > +} > + > +mesa_format > +_mesa_format_from_array_format(uint32_t array_format) > +{ > + mesa_array_format af; > + unsigned f; > + > + af.as_uint = array_format; > + af.pad = 0; > + if (!_mesa_little_endian()) > + af = array_format_flip_channels(af); > + > + assert(af.array_format_bit); > + for (f = 1; f < MESA_FORMAT_COUNT; ++f) > + if (_mesa_get_format_info(f)->ArrayFormat.as_uint == af.as_uint) > + return f; > + > + return MESA_FORMAT_NONE; > +} > > /** Is the given format a compressed format? */ > GLboolean > @@ -278,7 +333,6 @@ _mesa_is_format_compressed(mesa_format format) > return info->BlockWidth > 1 || info->BlockHeight > 1; > } > > - </div></div>Spurious whitespace change. > /** > * Determine if the given format represents a packed depth/stencil buffer. > */ > diff --git a/src/mesa/main/formats.h b/src/mesa/main/formats.h > index 213ab56..8b62788 100644 > --- a/src/mesa/main/formats.h > +++ b/src/mesa/main/formats.h > @@ -81,6 +81,62 @@ enum { > MESA_FORMAT_SWIZZLE_NONE = 6, > }; > > +enum mesa_array_format_datatype { > + MESA_ARRAY_FORMAT_TYPE_UBYTE = 0x0, > + MESA_ARRAY_FORMAT_TYPE_USHORT = 0x1, > + MESA_ARRAY_FORMAT_TYPE_UINT = 0x2, > + MESA_ARRAY_FORMAT_TYPE_BYTE = 0x4, > + MESA_ARRAY_FORMAT_TYPE_SHORT = 0x5, > + MESA_ARRAY_FORMAT_TYPE_INT = 0x6, > + MESA_ARRAY_FORMAT_TYPE_HALF = 0xd, > + MESA_ARRAY_FORMAT_TYPE_FLOAT = 0xe, > +}; > + > +#define MESA_ARRAY_FORMAT_TYPE_IS_SIGNED 0x4 > +#define MESA_ARRAY_FORMAT_TYPE_IS_FLOAT 0x8 > +#define MESA_ARRAY_FORMAT_BIT 0x80000000 This... > + > +typedef union { > + struct { > + enum mesa_array_format_datatype type:4; > + bool normalized:1; > + unsigned num_channels:3; > + unsigned swizzle_x:3; > + unsigned swizzle_y:3; > + unsigned swizzle_z:3; > + unsigned swizzle_w:3; > + unsigned pad:11; > + unsigned array_format_bit:1; /* Must always be 1 */ ...and this are not correct on big-endian. </blockquote><div> </div><div>Bah! I originally did this as a bitfield in a uint32_t and then decided that the union was easier. Probably best to go back to the bitfield... </div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> > + }; > + uint32_t as_uint; > +} mesa_array_format; > + > +static const mesa_array_format _mesa_array_format_none = {{ > + MESA_ARRAY_FORMAT_TYPE_UBYTE, > + 0, 0, 0, 0, 0, 0, 0, 0 > +}}; > + > +static inline unsigned > +_mesa_ilog2(unsigned x) > +{ > + uint8_t i; I'd either make this unsigned or uint_fast8_t... I'd bet that it doesn't make any difference. <div class="HOEnZb"><div class="h5"> > + for (i = 1; i < 32; ++i) > + if (x <= (1u << i)) > + return i; > + return 32; > +} > + > +#define MESA_ARRAY_FORMAT_TYPE(SIZE, SIGNED, IS_FLOAT, NORM) ( \ > + ((_mesa_ilog2(SIZE)) & MESA_ARRAY_FORMAT_TYPE_SIZE_MASK) | \ > + (((SIGNED) << 2 ) & MESA_ARRAY_FORMAT_TYPE_IS_SIGNED) | \ > + (((IS_FLOAT) << 3 ) & MESA_ARRAY_FORMAT_TYPE_IS_FLOAT) > + > +static inline int > +_mesa_array_format_datatype_size(enum mesa_array_format_datatype type) > +{ > + return 1 << (type & 0x3); > +} > + > /** > * Mesa texture/renderbuffer image formats. > */ > @@ -469,6 +525,12 @@ _mesa_get_format_block_size(mesa_format format, GLuint *bw, GLuint *bh); > extern void > _mesa_get_format_swizzle(mesa_format format, uint8_t swizzle_out[4]); > > +extern uint32_t > +_mesa_format_to_array_format(mesa_format format); > + > +extern mesa_format > +_mesa_format_from_array_format(uint32_t array_format); > + > extern GLboolean > _mesa_is_format_compressed(mesa_format format); > > </div></div><div class="HOEnZb"><div class="h5">_______________________________________________ mesa-dev mailing list <a href="mailto:mesa-dev@lists.freedesktop.org">mesa-dev@lists.freedesktop.org</a> <a href="http://lists.freedesktop.org/mailman/listinfo/mesa-dev" target="_blank">http://lists.freedesktop.org/mailman/listinfo/mesa-dev</a> </div></div></blockquote></div> </div></div>