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