src/gallium/auxiliary/util/u_format_pack.py

   1 #!/usr/bin/env python
   2
   3 '''
   4 /**************************************************************************
   5  *
   6  * Copyright 2009-2010 VMware, Inc.
   7  * All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29  **************************************************************************/
  30
  31 /**
  32  * @file
  33  * Pixel format packing and unpacking functions.
  34  *
  35  * @author Jose Fonseca <jfonseca@vmware.com>
  36  */
  37 '''
  38
  39
  40 from u_format_parse import *
  41
  42
  43 def inv_swizzles(swizzles):
  44     '''Return an array[4] of inverse swizzle terms'''
  45     '''Only pick the first matching value to avoid l8 getting blue and i8 getting alpha'''
  46     inv_swizzle = [None]*4
  47     for i in range(4):
  48         swizzle = swizzles[i]
  49         if swizzle < 4 and inv_swizzle[swizzle] == None:
  50             inv_swizzle[swizzle] = i
  51     return inv_swizzle
  52
  53 def print_channels(format, func):
  54     if format.nr_channels() <= 1:
  55         func(format.le_channels, format.le_swizzles)
  56     else:
  57         print '#ifdef PIPE_ARCH_BIG_ENDIAN'
  58         func(format.be_channels, format.be_swizzles)
  59         print '#else'
  60         func(format.le_channels, format.le_swizzles)
  61         print '#endif'
  62
  63 def generate_format_type(format):
  64     '''Generate a structure that describes the format.'''
  65
  66     assert format.layout == PLAIN
  67
  68     def generate_bitfields(channels, swizzles):
  69         for channel in channels:
  70             if channel.type == VOID:
  71                 if channel.size:
  72                     print '      unsigned %s:%u;' % (channel.name, channel.size)
  73             elif channel.type == UNSIGNED:
  74                 print '      unsigned %s:%u;' % (channel.name, channel.size)
  75             elif channel.type in (SIGNED, FIXED):
  76                 print '      int %s:%u;' % (channel.name, channel.size)
  77             elif channel.type == FLOAT:
  78                 if channel.size == 64:
  79                     print '      double %s;' % (channel.name)
  80                 elif channel.size == 32:
  81                     print '      float %s;' % (channel.name)
  82                 else:
  83                     print '      unsigned %s:%u;' % (channel.name, channel.size)
  84             else:
  85                 assert 0
  86
  87     def generate_full_fields(channels, swizzles):
  88         for channel in channels:
  89             assert channel.size % 8 == 0 and is_pot(channel.size)
  90             if channel.type == VOID:
  91                 if channel.size:
  92                     print '      uint%u_t %s;' % (channel.size, channel.name)
  93             elif channel.type == UNSIGNED:
  94                 print '      uint%u_t %s;' % (channel.size, channel.name)
  95             elif channel.type in (SIGNED, FIXED):
  96                 print '      int%u_t %s;' % (channel.size, channel.name)
  97             elif channel.type == FLOAT:
  98                 if channel.size == 64:
  99                     print '      double %s;' % (channel.name)
 100                 elif channel.size == 32:
 101                     print '      float %s;' % (channel.name)
 102                 elif channel.size == 16:
 103                     print '      uint16_t %s;' % (channel.name)
 104                 else:
 105                     assert 0
 106             else:
 107                 assert 0
 108
 109     print 'union util_format_%s {' % format.short_name()
 110
 111     if format.block_size() in (8, 16, 32, 64):
 112         print '   uint%u_t value;' % (format.block_size(),)
 113
 114     use_bitfields = False
 115     for channel in format.le_channels:
 116         if channel.size % 8 or not is_pot(channel.size):
 117             use_bitfields = True
 118
 119     print '   struct {'
 120     if use_bitfields:
 121         print_channels(format, generate_bitfields)
 122     else:
 123         print_channels(format, generate_full_fields)
 124     print '   } chan;'
 125     print '};'
 126     print
 127
 128
 129 def is_format_supported(format):
 130     '''Determines whether we actually have the plumbing necessary to generate the
 131     to read/write to/from this format.'''
 132
 133     # FIXME: Ideally we would support any format combination here.
 134
 135     if format.layout != PLAIN:
 136         return False
 137
 138     for i in range(4):
 139         channel = format.le_channels[i]
 140         if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT, FIXED):
 141             return False
 142         if channel.type == FLOAT and channel.size not in (16, 32, 64):
 143             return False
 144
 145     return True
 146
 147 def native_type(format):
 148     '''Get the native appropriate for a format.'''
 149
 150     if format.name == 'PIPE_FORMAT_R11G11B10_FLOAT':
 151         return 'uint32_t'
 152     if format.name == 'PIPE_FORMAT_R9G9B9E5_FLOAT':
 153         return 'uint32_t'
 154
 155     if format.layout == PLAIN:
 156         if not format.is_array():
 157             # For arithmetic pixel formats return the integer type that matches the whole pixel
 158             return 'uint%u_t' % format.block_size()
 159         else:
 160             # For array pixel formats return the integer type that matches the color channel
 161             channel = format.array_element()
 162             if channel.type in (UNSIGNED, VOID):
 163                 return 'uint%u_t' % channel.size
 164             elif channel.type in (SIGNED, FIXED):
 165                 return 'int%u_t' % channel.size
 166             elif channel.type == FLOAT:
 167                 if channel.size == 16:
 168                     return 'uint16_t'
 169                 elif channel.size == 32:
 170                     return 'float'
 171                 elif channel.size == 64:
 172                     return 'double'
 173                 else:
 174                     assert False
 175             else:
 176                 assert False
 177     else:
 178         assert False
 179
 180
 181 def intermediate_native_type(bits, sign):
 182     '''Find a native type adequate to hold intermediate results of the request bit size.'''
 183
 184     bytes = 4 # don't use anything smaller than 32bits
 185     while bytes * 8 < bits:
 186         bytes *= 2
 187     bits = bytes*8
 188
 189     if sign:
 190         return 'int%u_t' % bits
 191     else:
 192         return 'uint%u_t' % bits
 193
 194
 195 def get_one_shift(type):
 196     '''Get the number of the bit that matches unity for this type.'''
 197     if type.type == 'FLOAT':
 198         assert False
 199     if not type.norm:
 200         return 0
 201     if type.type == UNSIGNED:
 202         return type.size
 203     if type.type == SIGNED:
 204         return type.size - 1
 205     if type.type == FIXED:
 206         return type.size / 2
 207     assert False
 208
 209
 210 def truncate_mantissa(x, bits):
 211     '''Truncate an integer so it can be represented exactly with a floating
 212     point mantissa'''
 213
 214     assert isinstance(x, (int, long))
 215
 216     s = 1
 217     if x < 0:
 218         s = -1
 219         x = -x
 220
 221     # We can represent integers up to mantissa + 1 bits exactly
 222     mask = (1 << (bits + 1)) - 1
 223
 224     # Slide the mask until the MSB matches
 225     shift = 0
 226     while (x >> shift) & ~mask:
 227         shift += 1
 228
 229     x &= mask << shift
 230     x *= s
 231     return x
 232
 233
 234 def value_to_native(type, value):
 235     '''Get the value of unity for this type.'''
 236     if type.type == FLOAT:
 237         if type.size <= 32 \
 238             and isinstance(value, (int, long)):
 239             return truncate_mantissa(value, 23)
 240         return value
 241     if type.type == FIXED:
 242         return int(value * (1 << (type.size/2)))
 243     if not type.norm:
 244         return int(value)
 245     if type.type == UNSIGNED:
 246         return int(value * ((1 << type.size) - 1))
 247     if type.type == SIGNED:
 248         return int(value * ((1 << (type.size - 1)) - 1))
 249     assert False
 250
 251
 252 def native_to_constant(type, value):
 253     '''Get the value of unity for this type.'''
 254     if type.type == FLOAT:
 255         if type.size <= 32:
 256             return "%.1ff" % float(value)
 257         else:
 258             return "%.1f" % float(value)
 259     else:
 260         return str(int(value))
 261
 262
 263 def get_one(type):
 264     '''Get the value of unity for this type.'''
 265     return value_to_native(type, 1)
 266
 267
 268 def clamp_expr(src_channel, dst_channel, dst_native_type, value):
 269     '''Generate the expression to clamp the value in the source type to the
 270     destination type range.'''
 271
 272     if src_channel == dst_channel:
 273         return value
 274
 275     src_min = src_channel.min()
 276     src_max = src_channel.max()
 277     dst_min = dst_channel.min()
 278     dst_max = dst_channel.max()
 279
 280     # Translate the destination range to the src native value
 281     dst_min_native = native_to_constant(src_channel, value_to_native(src_channel, dst_min))
 282     dst_max_native = native_to_constant(src_channel, value_to_native(src_channel, dst_max))
 283
 284     if src_min < dst_min and src_max > dst_max:
 285         return 'CLAMP(%s, %s, %s)' % (value, dst_min_native, dst_max_native)
 286
 287     if src_max > dst_max:
 288         return 'MIN2(%s, %s)' % (value, dst_max_native)
 289
 290     if src_min < dst_min:
 291         return 'MAX2(%s, %s)' % (value, dst_min_native)
 292
 293     return value
 294
 295
 296 def conversion_expr(src_channel,
 297                     dst_channel, dst_native_type,
 298                     value,
 299                     clamp=True,
 300                     src_colorspace = RGB,
 301                     dst_colorspace = RGB):
 302     '''Generate the expression to convert a value between two types.'''
 303
 304     if src_colorspace != dst_colorspace:
 305         if src_colorspace == SRGB:
 306             assert src_channel.type == UNSIGNED
 307             assert src_channel.norm
 308             assert src_channel.size <= 8
 309             assert src_channel.size >= 4
 310             assert dst_colorspace == RGB
 311             if src_channel.size < 8:
 312                 value = '%s << %x | %s >> %x' % (value, 8 - src_channel.size, value, 2 * src_channel.size - 8)
 313             if dst_channel.type == FLOAT:
 314                 return 'util_format_srgb_8unorm_to_linear_float(%s)' % value
 315             else:
 316                 assert dst_channel.type == UNSIGNED
 317                 assert dst_channel.norm
 318                 assert dst_channel.size == 8
 319                 return 'util_format_srgb_to_linear_8unorm(%s)' % value
 320         elif dst_colorspace == SRGB:
 321             assert dst_channel.type == UNSIGNED
 322             assert dst_channel.norm
 323             assert dst_channel.size <= 8
 324             assert src_colorspace == RGB
 325             if src_channel.type == FLOAT:
 326                 value =  'util_format_linear_float_to_srgb_8unorm(%s)' % value
 327             else:
 328                 assert src_channel.type == UNSIGNED
 329                 assert src_channel.norm
 330                 assert src_channel.size == 8
 331                 value = 'util_format_linear_to_srgb_8unorm(%s)' % value
 332             # XXX rounding is all wrong.
 333             if dst_channel.size < 8:
 334                 return '%s >> %x' % (value, 8 - dst_channel.size)
 335             else:
 336                 return value
 337         elif src_colorspace == ZS:
 338             pass
 339         elif dst_colorspace == ZS:
 340             pass
 341         else:
 342             assert 0
 343
 344     if src_channel == dst_channel:
 345         return value
 346
 347     src_type = src_channel.type
 348     src_size = src_channel.size
 349     src_norm = src_channel.norm
 350     src_pure = src_channel.pure
 351
 352     # Promote half to float
 353     if src_type == FLOAT and src_size == 16:
 354         value = 'util_half_to_float(%s)' % value
 355         src_size = 32
 356
 357     # Special case for float <-> ubytes for more accurate results
 358     # Done before clamping since these functions already take care of that
 359     if src_type == UNSIGNED and src_norm and src_size == 8 and dst_channel.type == FLOAT and dst_channel.size == 32:
 360         return 'ubyte_to_float(%s)' % value
 361     if src_type == FLOAT and src_size == 32 and dst_channel.type == UNSIGNED and dst_channel.norm and dst_channel.size == 8:
 362         return 'float_to_ubyte(%s)' % value
 363
 364     if clamp:
 365         if dst_channel.type != FLOAT or src_type != FLOAT:
 366             value = clamp_expr(src_channel, dst_channel, dst_native_type, value)
 367
 368     if src_type in (SIGNED, UNSIGNED) and dst_channel.type in (SIGNED, UNSIGNED):
 369         if not src_norm and not dst_channel.norm:
 370             # neither is normalized -- just cast
 371             return '(%s)%s' % (dst_native_type, value)
 372
 373         src_one = get_one(src_channel)
 374         dst_one = get_one(dst_channel)
 375
 376         if src_one > dst_one and src_norm and dst_channel.norm:
 377             # We can just bitshift
 378             src_shift = get_one_shift(src_channel)
 379             dst_shift = get_one_shift(dst_channel)
 380             value = '(%s >> %s)' % (value, src_shift - dst_shift)
 381         else:
 382             # We need to rescale using an intermediate type big enough to hold the multiplication of both
 383             tmp_native_type = intermediate_native_type(src_size + dst_channel.size, src_channel.sign and dst_channel.sign)
 384             value = '((%s)%s)' % (tmp_native_type, value)
 385             value = '(%s * 0x%x / 0x%x)' % (value, dst_one, src_one)
 386         value = '(%s)%s' % (dst_native_type, value)
 387         return value
 388
 389     # Promote to either float or double
 390     if src_type != FLOAT:
 391         if src_norm or src_type == FIXED:
 392             one = get_one(src_channel)
 393             if src_size <= 23:
 394                 value = '(%s * (1.0f/0x%x))' % (value, one)
 395                 if dst_channel.size <= 32:
 396                     value = '(float)%s' % value
 397                 src_size = 32
 398             else:
 399                 # bigger than single precision mantissa, use double
 400                 value = '(%s * (1.0/0x%x))' % (value, one)
 401                 src_size = 64
 402             src_norm = False
 403         else:
 404             if src_size <= 23 or dst_channel.size <= 32:
 405                 value = '(float)%s' % value
 406                 src_size = 32
 407             else:
 408                 # bigger than single precision mantissa, use double
 409                 value = '(double)%s' % value
 410                 src_size = 64
 411         src_type = FLOAT
 412
 413     # Convert double or float to non-float
 414     if dst_channel.type != FLOAT:
 415         if dst_channel.norm or dst_channel.type == FIXED:
 416             dst_one = get_one(dst_channel)
 417             if dst_channel.size <= 23:
 418                 value = 'util_iround(%s * 0x%x)' % (value, dst_one)
 419             else:
 420                 # bigger than single precision mantissa, use double
 421                 value = '(%s * (double)0x%x)' % (value, dst_one)
 422         value = '(%s)%s' % (dst_native_type, value)
 423     else:
 424         # Cast double to float when converting to either half or float
 425         if dst_channel.size <= 32 and src_size > 32:
 426             value = '(float)%s' % value
 427             src_size = 32
 428
 429         if dst_channel.size == 16:
 430             value = 'util_float_to_half(%s)' % value
 431         elif dst_channel.size == 64 and src_size < 64:
 432             value = '(double)%s' % value
 433
 434     return value
 435
 436
 437 def generate_unpack_kernel(format, dst_channel, dst_native_type):
 438
 439     if not is_format_supported(format):
 440         return
 441
 442     assert format.layout == PLAIN
 443
 444     src_native_type = native_type(format)
 445
 446     def unpack_from_bitmask(channels, swizzles):
 447         depth = format.block_size()
 448         print '         uint%u_t value = *(const uint%u_t *)src;' % (depth, depth)
 449
 450         # Declare the intermediate variables
 451         for i in range(format.nr_channels()):
 452             src_channel = channels[i]
 453             if src_channel.type == UNSIGNED:
 454                 print '         uint%u_t %s;' % (depth, src_channel.name)
 455             elif src_channel.type == SIGNED:
 456                 print '         int%u_t %s;' % (depth, src_channel.name)
 457
 458         # Compute the intermediate unshifted values
 459         for i in range(format.nr_channels()):
 460             src_channel = channels[i]
 461             value = 'value'
 462             shift = src_channel.shift
 463             if src_channel.type == UNSIGNED:
 464                 if shift:
 465                     value = '%s >> %u' % (value, shift)
 466                 if shift + src_channel.size < depth:
 467                     value = '(%s) & 0x%x' % (value, (1 << src_channel.size) - 1)
 468             elif src_channel.type == SIGNED:
 469                 if shift + src_channel.size < depth:
 470                     # Align the sign bit
 471                     lshift = depth - (shift + src_channel.size)
 472                     value = '%s << %u' % (value, lshift)
 473                 # Cast to signed
 474                 value = '(int%u_t)(%s) ' % (depth, value)
 475                 if src_channel.size < depth:
 476                     # Align the LSB bit
 477                     rshift = depth - src_channel.size
 478                     value = '(%s) >> %u' % (value, rshift)
 479             else:
 480                 value = None
 481
 482             if value is not None:
 483                 print '         %s = %s;' % (src_channel.name, value)
 484
 485         # Convert, swizzle, and store final values
 486         for i in range(4):
 487             swizzle = swizzles[i]
 488             if swizzle < 4:
 489                 src_channel = channels[swizzle]
 490                 src_colorspace = format.colorspace
 491                 if src_colorspace == SRGB and i == 3:
 492                     # Alpha channel is linear
 493                     src_colorspace = RGB
 494                 value = src_channel.name
 495                 value = conversion_expr(src_channel,
 496                                         dst_channel, dst_native_type,
 497                                         value,
 498                                         src_colorspace = src_colorspace)
 499             elif swizzle == SWIZZLE_0:
 500                 value = '0'
 501             elif swizzle == SWIZZLE_1:
 502                 value = get_one(dst_channel)
 503             elif swizzle == SWIZZLE_NONE:
 504                 value = '0'
 505             else:
 506                 assert False
 507             print '         dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])
 508
 509     def unpack_from_union(channels, swizzles):
 510         print '         union util_format_%s pixel;' % format.short_name()
 511         print '         memcpy(&pixel, src, sizeof pixel);'
 512
 513         for i in range(4):
 514             swizzle = swizzles[i]
 515             if swizzle < 4:
 516                 src_channel = channels[swizzle]
 517                 src_colorspace = format.colorspace
 518                 if src_colorspace == SRGB and i == 3:
 519                     # Alpha channel is linear
 520                     src_colorspace = RGB
 521                 value = 'pixel.chan.%s' % src_channel.name
 522                 value = conversion_expr(src_channel,
 523                                         dst_channel, dst_native_type,
 524                                         value,
 525                                         src_colorspace = src_colorspace)
 526             elif swizzle == SWIZZLE_0:
 527                 value = '0'
 528             elif swizzle == SWIZZLE_1:
 529                 value = get_one(dst_channel)
 530             elif swizzle == SWIZZLE_NONE:
 531                 value = '0'
 532             else:
 533                 assert False
 534             print '         dst[%u] = %s; /* %s */' % (i, value, 'rgba'[i])
 535
 536     if format.is_bitmask():
 537         print_channels(format, unpack_from_bitmask)
 538     else:
 539         print_channels(format, unpack_from_union)
 540
 541
 542 def generate_pack_kernel(format, src_channel, src_native_type):
 543
 544     if not is_format_supported(format):
 545         return
 546
 547     dst_native_type = native_type(format)
 548
 549     assert format.layout == PLAIN
 550
 551     def pack_into_bitmask(channels, swizzles):
 552         inv_swizzle = inv_swizzles(swizzles)
 553
 554         depth = format.block_size()
 555         print '         uint%u_t value = 0;' % depth
 556
 557         for i in range(4):
 558             dst_channel = channels[i]
 559             shift = dst_channel.shift
 560             if inv_swizzle[i] is not None:
 561                 value ='src[%u]' % inv_swizzle[i]
 562                 dst_colorspace = format.colorspace
 563                 if dst_colorspace == SRGB and inv_swizzle[i] == 3:
 564                     # Alpha channel is linear
 565                     dst_colorspace = RGB
 566                 value = conversion_expr(src_channel,
 567                                         dst_channel, dst_native_type,
 568                                         value,
 569                                         dst_colorspace = dst_colorspace)
 570                 if dst_channel.type in (UNSIGNED, SIGNED):
 571                     if shift + dst_channel.size < depth:
 572                         value = '(%s) & 0x%x' % (value, (1 << dst_channel.size) - 1)
 573                     if shift:
 574                         value = '(%s) << %u' % (value, shift)
 575                     if dst_channel.type == SIGNED:
 576                         # Cast to unsigned
 577                         value = '(uint%u_t)(%s) ' % (depth, value)
 578                 else:
 579                     value = None
 580                 if value is not None:
 581                     print '         value |= %s;' % (value)
 582
 583         print '         *(uint%u_t *)dst = value;' % depth
 584
 585     def pack_into_union(channels, swizzles):
 586         inv_swizzle = inv_swizzles(swizzles)
 587
 588         print '         union util_format_%s pixel;' % format.short_name()
 589
 590         for i in range(4):
 591             dst_channel = channels[i]
 592             width = dst_channel.size
 593             if inv_swizzle[i] is None:
 594                 continue
 595             dst_colorspace = format.colorspace
 596             if dst_colorspace == SRGB and inv_swizzle[i] == 3:
 597                 # Alpha channel is linear
 598                 dst_colorspace = RGB
 599             value ='src[%u]' % inv_swizzle[i]
 600             value = conversion_expr(src_channel,
 601                                     dst_channel, dst_native_type,
 602                                     value,
 603                                     dst_colorspace = dst_colorspace)
 604             print '         pixel.chan.%s = %s;' % (dst_channel.name, value)
 605
 606         print '         memcpy(dst, &pixel, sizeof pixel);'
 607
 608     if format.is_bitmask():
 609         print_channels(format, pack_into_bitmask)
 610     else:
 611         print_channels(format, pack_into_union)
 612
 613
 614 def generate_format_unpack(format, dst_channel, dst_native_type, dst_suffix):
 615     '''Generate the function to unpack pixels from a particular format'''
 616
 617     name = format.short_name()
 618
 619     print 'static inline void'
 620     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)
 621     print '{'
 622
 623     if is_format_supported(format):
 624         print '   unsigned x, y;'
 625         print '   for(y = 0; y < height; y += %u) {' % (format.block_height,)
 626         print '      %s *dst = dst_row;' % (dst_native_type)
 627         print '      const uint8_t *src = src_row;'
 628         print '      for(x = 0; x < width; x += %u) {' % (format.block_width,)
 629
 630         generate_unpack_kernel(format, dst_channel, dst_native_type)
 631
 632         print '         src += %u;' % (format.block_size() / 8,)
 633         print '         dst += 4;'
 634         print '      }'
 635         print '      src_row += src_stride;'
 636         print '      dst_row += dst_stride/sizeof(*dst_row);'
 637         print '   }'
 638
 639     print '}'
 640     print
 641
 642
 643 def generate_format_pack(format, src_channel, src_native_type, src_suffix):
 644     '''Generate the function to pack pixels to a particular format'''
 645
 646     name = format.short_name()
 647
 648     print 'static inline void'
 649     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)
 650     print '{'
 651
 652     if is_format_supported(format):
 653         print '   unsigned x, y;'
 654         print '   for(y = 0; y < height; y += %u) {' % (format.block_height,)
 655         print '      const %s *src = src_row;' % (src_native_type)
 656         print '      uint8_t *dst = dst_row;'
 657         print '      for(x = 0; x < width; x += %u) {' % (format.block_width,)
 658
 659         generate_pack_kernel(format, src_channel, src_native_type)
 660
 661         print '         src += 4;'
 662         print '         dst += %u;' % (format.block_size() / 8,)
 663         print '      }'
 664         print '      dst_row += dst_stride;'
 665         print '      src_row += src_stride/sizeof(*src_row);'
 666         print '   }'
 667
 668     print '}'
 669     print
 670
 671
 672 def generate_format_fetch(format, dst_channel, dst_native_type, dst_suffix):
 673     '''Generate the function to unpack pixels from a particular format'''
 674
 675     name = format.short_name()
 676
 677     print 'static inline void'
 678     print 'util_format_%s_fetch_%s(%s *dst, const uint8_t *src, unsigned i, unsigned j)' % (name, dst_suffix, dst_native_type)
 679     print '{'
 680
 681     if is_format_supported(format):
 682         generate_unpack_kernel(format, dst_channel, dst_native_type)
 683
 684     print '}'
 685     print
 686
 687
 688 def is_format_hand_written(format):
 689     return format.layout in ('s3tc', 'rgtc', 'etc', 'bptc', 'astc', 'subsampled', 'other') or format.colorspace == ZS
 690
 691
 692 def generate(formats):
 693     print
 694     print '#include "pipe/p_compiler.h"'
 695     print '#include "u_math.h"'
 696     print '#include "u_half.h"'
 697     print '#include "u_format.h"'
 698     print '#include "u_format_other.h"'
 699     print '#include "util/format_srgb.h"'
 700     print '#include "u_format_yuv.h"'
 701     print '#include "u_format_zs.h"'
 702     print
 703
 704     for format in formats:
 705         if not is_format_hand_written(format):
 706
 707             if is_format_supported(format):
 708                 generate_format_type(format)
 709
 710             if format.is_pure_unsigned():
 711                 native_type = 'unsigned'
 712                 suffix = 'unsigned'
 713                 channel = Channel(UNSIGNED, False, True, 32)
 714
 715                 generate_format_unpack(format, channel, native_type, suffix)
 716                 generate_format_pack(format, channel, native_type, suffix)
 717                 generate_format_fetch(format, channel, native_type, suffix)
 718
 719                 channel = Channel(SIGNED, False, True, 32)
 720                 native_type = 'int'
 721                 suffix = 'signed'
 722                 generate_format_unpack(format, channel, native_type, suffix)
 723                 generate_format_pack(format, channel, native_type, suffix)
 724             elif format.is_pure_signed():
 725                 native_type = 'int'
 726                 suffix = 'signed'
 727                 channel = Channel(SIGNED, False, True, 32)
 728
 729                 generate_format_unpack(format, channel, native_type, suffix)
 730                 generate_format_pack(format, channel, native_type, suffix)
 731                 generate_format_fetch(format, channel, native_type, suffix)
 732
 733                 native_type = 'unsigned'
 734                 suffix = 'unsigned'
 735                 channel = Channel(UNSIGNED, False, True, 32)
 736                 generate_format_unpack(format, channel, native_type, suffix)
 737                 generate_format_pack(format, channel, native_type, suffix)
 738             else:
 739                 channel = Channel(FLOAT, False, False, 32)
 740                 native_type = 'float'
 741                 suffix = 'rgba_float'
 742
 743                 generate_format_unpack(format, channel, native_type, suffix)
 744                 generate_format_pack(format, channel, native_type, suffix)
 745                 generate_format_fetch(format, channel, native_type, suffix)
 746
 747                 channel = Channel(UNSIGNED, True, False, 8)
 748                 native_type = 'uint8_t'
 749                 suffix = 'rgba_8unorm'
 750
 751                 generate_format_unpack(format, channel, native_type, suffix)
 752                 generate_format_pack(format, channel, native_type, suffix)
 753