From 96eda2ec0d8c462468de9fa848e1d5f9be014ab5 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 18 Aug 2024 15:09:51 +1000 Subject: [PATCH] std/etc2: support transparency --- .../cgen/base/pixconv-submodule-regular.c | 103 +++++ release/c/wuffs-unsupported-snapshot.c | 362 ++++++++++++++++-- std/etc2/decode_etc2.wuffs | 237 +++++++++--- test/c/std/wbmp.c | 4 + ...masked-with-muybridge.etc2.bgra-binary.pkm | Bin 0 -> 520 bytes ...ked-with-muybridge.etc2.bgra-nonpremul.pkm | Bin 0 -> 1024 bytes test/nia-checksums-of-data.txt | 2 + 7 files changed, 627 insertions(+), 81 deletions(-) create mode 100644 test/data/hippopotamus.masked-with-muybridge.etc2.bgra-binary.pkm create mode 100644 test/data/hippopotamus.masked-with-muybridge.etc2.bgra-nonpremul.pkm diff --git a/internal/cgen/base/pixconv-submodule-regular.c b/internal/cgen/base/pixconv-submodule-regular.c index 702b4c3e..7855accf 100644 --- a/internal/cgen/base/pixconv-submodule-regular.c +++ b/internal/cgen/base/pixconv-submodule-regular.c @@ -250,6 +250,10 @@ wuffs_base__pixel_buffer__set_color_u32_at( wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( color)); break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + wuffs_base__poke_u32le__no_bounds_check( + row + (4 * ((size_t)x)), (color >> 31) ? (color | 0xFF000000) : 0); + break; case WUFFS_BASE__PIXEL_FORMAT__RGB: wuffs_base__poke_u24le__no_bounds_check( @@ -5693,6 +5697,100 @@ wuffs_private_impl__pixel_swizzler__prepare__bgra_premul( return NULL; } +static inline WUFFS_BASE__FORCE_INLINE wuffs_base__pixel_swizzler__func // +wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( + wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_pixfmt, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src_palette, + wuffs_base__pixel_blend blend) { + switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGR: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_copy_4_4; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_copy_4_4; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGB: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr__rgba_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: +#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) + if (wuffs_base__cpu_arch__have_x86_sse42()) { + return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; + } +#endif + return wuffs_private_impl__swizzle_swap_rgbx_bgrx; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: +#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) + if (wuffs_base__cpu_arch__have_x86_sse42()) { + return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; + } +#endif + return wuffs_private_impl__swizzle_swap_rgbx_bgrx; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; + } + return NULL; + } + return NULL; +} + static inline WUFFS_BASE__FORCE_INLINE wuffs_base__pixel_swizzler__func // wuffs_private_impl__pixel_swizzler__prepare__bgrx( wuffs_base__pixel_swizzler* p, @@ -6111,6 +6209,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, p, dst_pixfmt, dst_palette, src_palette, blend); break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + func = wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( + p, dst_pixfmt, dst_palette, src_palette, blend); + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRX: func = wuffs_private_impl__pixel_swizzler__prepare__bgrx( p, dst_pixfmt, dst_palette, src_palette, blend); diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 38b5068b..6f6892a0 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -9133,6 +9133,7 @@ struct wuffs_etc2__decoder__struct { } private_impl; struct { + uint64_t f_alphas[64]; uint64_t f_colors[64]; uint8_t f_buffer[4096]; @@ -22723,6 +22724,10 @@ wuffs_base__pixel_buffer__set_color_u32_at( wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( color)); break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + wuffs_base__poke_u32le__no_bounds_check( + row + (4 * ((size_t)x)), (color >> 31) ? (color | 0xFF000000) : 0); + break; case WUFFS_BASE__PIXEL_FORMAT__RGB: wuffs_base__poke_u24le__no_bounds_check( @@ -28166,6 +28171,100 @@ wuffs_private_impl__pixel_swizzler__prepare__bgra_premul( return NULL; } +static inline WUFFS_BASE__FORCE_INLINE wuffs_base__pixel_swizzler__func // +wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( + wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_pixfmt, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src_palette, + wuffs_base__pixel_blend blend) { + switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGR: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_copy_4_4; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_copy_4_4; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGB: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr__rgba_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: +#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) + if (wuffs_base__cpu_arch__have_x86_sse42()) { + return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; + } +#endif + return wuffs_private_impl__swizzle_swap_rgbx_bgrx; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: +#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) + if (wuffs_base__cpu_arch__have_x86_sse42()) { + return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; + } +#endif + return wuffs_private_impl__swizzle_swap_rgbx_bgrx; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; + } + return NULL; + } + return NULL; +} + static inline WUFFS_BASE__FORCE_INLINE wuffs_base__pixel_swizzler__func // wuffs_private_impl__pixel_swizzler__prepare__bgrx( wuffs_base__pixel_swizzler* p, @@ -28584,6 +28683,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, p, dst_pixfmt, dst_palette, src_palette, blend); break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + func = wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( + p, dst_pixfmt, dst_palette, src_palette, blend); + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRX: func = wuffs_private_impl__pixel_swizzler__prepare__bgrx( p, dst_pixfmt, dst_palette, src_palette, blend); @@ -41004,7 +41108,7 @@ WUFFS_ETC2__DIFFS[8] WUFFS_BASE__POTENTIALLY_UNUSED = { }; static const uint32_t -WUFFS_ETC2__MODIFIERS[8][4] WUFFS_BASE__POTENTIALLY_UNUSED = { +WUFFS_ETC2__MODIFIERS[16][4] WUFFS_BASE__POTENTIALLY_UNUSED = { { 2u, 8u, 4294967294u, 4294967288u, }, { @@ -41022,6 +41126,23 @@ WUFFS_ETC2__MODIFIERS[8][4] WUFFS_BASE__POTENTIALLY_UNUSED = { }, { 47u, 183u, 4294967249u, 4294967113u, }, + { + 0u, 8u, 0u, 4294967288u, + }, { + 0u, 17u, 0u, 4294967279u, + }, { + 0u, 29u, 0u, 4294967267u, + }, { + 0u, 42u, 0u, 4294967254u, + }, { + 0u, 60u, 0u, 4294967236u, + }, { + 0u, 80u, 0u, 4294967216u, + }, { + 0u, 106u, 0u, 4294967190u, + }, { + 0u, 183u, 0u, 4294967113u, + }, }; static const uint8_t @@ -41029,6 +41150,44 @@ WUFFS_ETC2__T_H_MODIFIERS[8] WUFFS_BASE__POTENTIALLY_UNUSED = { 3u, 6u, 11u, 16u, 23u, 32u, 41u, 64u, }; +static const uint32_t +WUFFS_ETC2__ALPHA_MODIFIERS[16][8] WUFFS_BASE__POTENTIALLY_UNUSED = { + { + 4294967293u, 4294967290u, 4294967287u, 4294967281u, 2u, 5u, 8u, 14u, + }, { + 4294967293u, 4294967289u, 4294967286u, 4294967283u, 2u, 6u, 9u, 12u, + }, { + 4294967294u, 4294967291u, 4294967288u, 4294967283u, 1u, 4u, 7u, 12u, + }, { + 4294967294u, 4294967292u, 4294967290u, 4294967283u, 1u, 3u, 5u, 12u, + }, { + 4294967293u, 4294967290u, 4294967288u, 4294967284u, 2u, 5u, 7u, 11u, + }, { + 4294967293u, 4294967289u, 4294967287u, 4294967285u, 2u, 6u, 8u, 10u, + }, { + 4294967292u, 4294967289u, 4294967288u, 4294967285u, 3u, 6u, 7u, 10u, + }, { + 4294967293u, 4294967291u, 4294967288u, 4294967285u, 2u, 4u, 7u, 10u, + }, + { + 4294967294u, 4294967290u, 4294967288u, 4294967286u, 1u, 5u, 7u, 9u, + }, { + 4294967294u, 4294967291u, 4294967288u, 4294967286u, 1u, 4u, 7u, 9u, + }, { + 4294967294u, 4294967292u, 4294967288u, 4294967286u, 1u, 3u, 7u, 9u, + }, { + 4294967294u, 4294967291u, 4294967289u, 4294967286u, 1u, 4u, 6u, 9u, + }, { + 4294967293u, 4294967292u, 4294967289u, 4294967286u, 2u, 3u, 6u, 9u, + }, { + 4294967295u, 4294967294u, 4294967293u, 4294967286u, 0u, 1u, 2u, 9u, + }, { + 4294967292u, 4294967290u, 4294967288u, 4294967287u, 3u, 5u, 7u, 8u, + }, { + 4294967293u, 4294967291u, 4294967289u, 4294967287u, 2u, 4u, 6u, 8u, + }, +}; + static const uint8_t WUFFS_ETC2__CLAMP[1024] WUFFS_BASE__POTENTIALLY_UNUSED = { 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, @@ -41205,14 +41364,16 @@ static wuffs_base__empty_struct wuffs_etc2__decoder__decode_t_mode( wuffs_etc2__decoder* self, uint64_t a_bits, - uint32_t a_offset); + uint32_t a_offset, + bool a_transparent); WUFFS_BASE__GENERATED_C_CODE static wuffs_base__empty_struct wuffs_etc2__decoder__decode_h_mode( wuffs_etc2__decoder* self, uint64_t a_bits, - uint32_t a_offset); + uint32_t a_offset, + bool a_transparent); WUFFS_BASE__GENERATED_C_CODE static wuffs_base__empty_struct @@ -41232,8 +41393,14 @@ wuffs_etc2__decoder__decode_half_block( uint32_t a_g, uint32_t a_b, bool a_flip, + bool a_transparent, bool a_second); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__from_alphas_to_buffer( + wuffs_etc2__decoder* self); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_etc2__decoder__from_buffer_to_dst( @@ -41555,6 +41722,10 @@ wuffs_etc2__decoder__do_decode_image_config( } if ((v_c32 == 12337u) || (v_c32 == 16789554u) || (v_c32 == 151007282u)) { self->private_impl.f_pixfmt = 2415954056u; + } else if ((v_c32 == 50343986u) || (v_c32 == 167784498u)) { + self->private_impl.f_pixfmt = 2164295816u; + } else if ((v_c32 == 67121202u) || (v_c32 == 184561714u)) { + self->private_impl.f_pixfmt = 2197850248u; } else if ((v_c32 & 65535u) == 12338u) { status = wuffs_base__make_status(wuffs_etc2__error__unsupported_etc2_file); goto exit; @@ -42001,7 +42172,6 @@ wuffs_etc2__decoder__do_decode_frame( } self->private_impl.f_dst_x = 0u; self->private_impl.f_dst_y = 0u; - wuffs_private_impl__bulk_memset(&self->private_data.f_buffer[0], 4096u, 255u); v_remaining = (((self->private_impl.f_width + 3u) / 4u) * ((self->private_impl.f_height + 3u) / 4u)); while (v_remaining > 0u) { self->private_impl.f_num_buffered_blocks = wuffs_base__u32__min(v_remaining, 64u); @@ -42016,6 +42186,9 @@ wuffs_etc2__decoder__do_decode_frame( goto suspend; } wuffs_etc2__decoder__from_colors_to_buffer(self); + if (self->private_impl.f_pixfmt == 2164295816u) { + wuffs_etc2__decoder__from_alphas_to_buffer(self); + } v_status = wuffs_etc2__decoder__from_buffer_to_dst(self, a_dst); if ( ! wuffs_base__status__is_ok(&v_status)) { status = v_status; @@ -42075,34 +42248,65 @@ wuffs_etc2__decoder__from_src_to_colors( WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; while (v_bi < self->private_impl.f_num_buffered_blocks) { + if (self->private_impl.f_pixfmt == 2164295816u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + uint64_t t_0; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { + t_0 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); + iop_a_src += 8; + } else { + self->private_data.s_from_src_to_colors.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + while (true) { + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint64_t* scratch = &self->private_data.s_from_src_to_colors.scratch; + uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0); + if (num_bits_0 == 56) { + t_0 = ((uint64_t)(*scratch >> 0)); + break; + } + num_bits_0 += 8u; + *scratch |= ((uint64_t)(num_bits_0)); + } + } + self->private_data.f_alphas[v_bi] = t_0; + } + } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - uint64_t t_0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + uint64_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { - t_0 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); + t_1 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); iop_a_src += 8; } else { self->private_data.s_from_src_to_colors.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); goto suspend; } uint64_t* scratch = &self->private_data.s_from_src_to_colors.scratch; - uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFFu)); + uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFFu)); *scratch >>= 8; *scratch <<= 8; - *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0); - if (num_bits_0 == 56) { - t_0 = ((uint64_t)(*scratch >> 0)); + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1); + if (num_bits_1 == 56) { + t_1 = ((uint64_t)(*scratch >> 0)); break; } - num_bits_0 += 8u; - *scratch |= ((uint64_t)(num_bits_0)); + num_bits_1 += 8u; + *scratch |= ((uint64_t)(num_bits_1)); } } - self->private_data.f_colors[v_bi] = t_0; + self->private_data.f_colors[v_bi] = t_1; } v_bi += 1u; } @@ -42141,11 +42345,15 @@ wuffs_etc2__decoder__from_colors_to_buffer( uint32_t v_g1 = 0; uint32_t v_b0 = 0; uint32_t v_b1 = 0; + bool v_diff = false; + bool v_tran = false; bool v_flip = false; while (v_bi < self->private_impl.f_num_buffered_blocks) { v_color = self->private_data.f_colors[v_bi]; - if ((v_color & 8589934592u) == 0u) { + v_diff = ((v_color & 8589934592u) != 0u); + v_tran = ( ! v_diff && (self->private_impl.f_pixfmt == 2197850248u)); + if ( ! v_diff && (self->private_impl.f_pixfmt != 2197850248u)) { v_r0 = ((uint32_t)((15u & (v_color >> 60u)))); v_r0 = ((v_r0 << 4u) | v_r0); v_r1 = ((uint32_t)((15u & (v_color >> 56u)))); @@ -42162,7 +42370,7 @@ wuffs_etc2__decoder__from_colors_to_buffer( v_r0 = ((uint32_t)((31u & (v_color >> 59u)))); v_r1 = ((uint32_t)(v_r0 + WUFFS_ETC2__DIFFS[(7u & (v_color >> 56u))])); if ((v_r1 >> 5u) != 0u) { - wuffs_etc2__decoder__decode_t_mode(self, v_color, (16u * v_bi)); + wuffs_etc2__decoder__decode_t_mode(self, v_color, (16u * v_bi), v_tran); v_bi += 1u; continue; } @@ -42171,7 +42379,7 @@ wuffs_etc2__decoder__from_colors_to_buffer( v_g0 = ((uint32_t)((31u & (v_color >> 51u)))); v_g1 = ((uint32_t)(v_g0 + WUFFS_ETC2__DIFFS[(7u & (v_color >> 48u))])); if ((v_g1 >> 5u) != 0u) { - wuffs_etc2__decoder__decode_h_mode(self, v_color, (16u * v_bi)); + wuffs_etc2__decoder__decode_h_mode(self, v_color, (16u * v_bi), v_tran); v_bi += 1u; continue; } @@ -42196,6 +42404,7 @@ wuffs_etc2__decoder__from_colors_to_buffer( v_g0, v_b0, v_flip, + v_tran, false); wuffs_etc2__decoder__decode_half_block(self, ((uint32_t)(v_color)), @@ -42205,6 +42414,7 @@ wuffs_etc2__decoder__from_colors_to_buffer( v_g1, v_b1, v_flip, + v_tran, true); v_bi += 1u; } @@ -42218,16 +42428,18 @@ static wuffs_base__empty_struct wuffs_etc2__decoder__decode_t_mode( wuffs_etc2__decoder* self, uint64_t a_bits, - uint32_t a_offset) { + uint32_t a_offset, + bool a_transparent) { uint8_t v_r[4] = {0}; uint8_t v_g[4] = {0}; uint8_t v_b[4] = {0}; + uint8_t v_a[4] = {0}; uint32_t v_which = 0; uint32_t v_delta = 0; uint32_t v_y = 0; uint32_t v_x = 0; uint32_t v_x4y = 0; - uint32_t v_i = 0; + uint32_t v_index = 0; uint32_t v_o = 0; v_r[0u] = ((uint8_t)(((uint8_t)((12u & (a_bits >> 57u)))) | ((uint8_t)((3u & (a_bits >> 56u)))))); @@ -42236,29 +42448,40 @@ wuffs_etc2__decoder__decode_t_mode( v_g[0u] = ((uint8_t)(((uint8_t)(v_g[0u] << 4u)) | v_g[0u])); v_b[0u] = ((uint8_t)((15u & (a_bits >> 48u)))); v_b[0u] = ((uint8_t)(((uint8_t)(v_b[0u] << 4u)) | v_b[0u])); + v_a[0u] = 255u; v_r[2u] = ((uint8_t)((15u & (a_bits >> 44u)))); v_r[2u] = ((uint8_t)(((uint8_t)(v_r[2u] << 4u)) | v_r[2u])); v_g[2u] = ((uint8_t)((15u & (a_bits >> 40u)))); v_g[2u] = ((uint8_t)(((uint8_t)(v_g[2u] << 4u)) | v_g[2u])); v_b[2u] = ((uint8_t)((15u & (a_bits >> 36u)))); v_b[2u] = ((uint8_t)(((uint8_t)(v_b[2u] << 4u)) | v_b[2u])); + v_a[2u] = 255u; v_which = (((uint32_t)((6u & (a_bits >> 33u)))) | ((uint32_t)((1u & (a_bits >> 32u))))); v_delta = ((uint32_t)(WUFFS_ETC2__T_H_MODIFIERS[v_which])); v_r[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) + v_delta)) & 1023u)]; v_g[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) + v_delta)) & 1023u)]; v_b[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) + v_delta)) & 1023u)]; + v_a[1u] = 255u; v_r[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) - v_delta)) & 1023u)]; v_g[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) - v_delta)) & 1023u)]; v_b[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) - v_delta)) & 1023u)]; + v_a[3u] = 255u; + if (a_transparent) { + v_r[2u] = 0u; + v_g[2u] = 0u; + v_b[2u] = 0u; + v_a[2u] = 0u; + } while (v_y < 4u) { v_x = 0u; while (v_x < 4u) { v_x4y = ((v_x * 4u) | v_y); - v_i = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); + v_index = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); - self->private_data.f_buffer[(v_o + 0u)] = v_b[v_i]; - self->private_data.f_buffer[(v_o + 1u)] = v_g[v_i]; - self->private_data.f_buffer[(v_o + 2u)] = v_r[v_i]; + self->private_data.f_buffer[(v_o + 0u)] = v_b[v_index]; + self->private_data.f_buffer[(v_o + 1u)] = v_g[v_index]; + self->private_data.f_buffer[(v_o + 2u)] = v_r[v_index]; + self->private_data.f_buffer[(v_o + 3u)] = v_a[v_index]; v_x += 1u; } v_y += 1u; @@ -42273,10 +42496,12 @@ static wuffs_base__empty_struct wuffs_etc2__decoder__decode_h_mode( wuffs_etc2__decoder* self, uint64_t a_bits, - uint32_t a_offset) { + uint32_t a_offset, + bool a_transparent) { uint8_t v_r[4] = {0}; uint8_t v_g[4] = {0}; uint8_t v_b[4] = {0}; + uint8_t v_a[4] = {0}; uint32_t v_rgb0 = 0; uint32_t v_rgb2 = 0; uint32_t v_which = 0; @@ -42284,7 +42509,7 @@ wuffs_etc2__decoder__decode_h_mode( uint32_t v_y = 0; uint32_t v_x = 0; uint32_t v_x4y = 0; - uint32_t v_i = 0; + uint32_t v_index = 0; uint32_t v_o = 0; v_r[0u] = ((uint8_t)((15u & (a_bits >> 59u)))); @@ -42309,24 +42534,35 @@ wuffs_etc2__decoder__decode_h_mode( v_r[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[0u])) - v_delta)) & 1023u)]; v_g[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[0u])) - v_delta)) & 1023u)]; v_b[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[0u])) - v_delta)) & 1023u)]; + v_a[1u] = 255u; v_r[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[0u])) + v_delta)) & 1023u)]; v_g[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[0u])) + v_delta)) & 1023u)]; v_b[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[0u])) + v_delta)) & 1023u)]; + v_a[0u] = 255u; v_r[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) - v_delta)) & 1023u)]; v_g[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) - v_delta)) & 1023u)]; v_b[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) - v_delta)) & 1023u)]; + v_a[3u] = 255u; v_r[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) + v_delta)) & 1023u)]; v_g[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) + v_delta)) & 1023u)]; v_b[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) + v_delta)) & 1023u)]; + v_a[2u] = 255u; + if (a_transparent) { + v_r[2u] = 0u; + v_g[2u] = 0u; + v_b[2u] = 0u; + v_a[2u] = 0u; + } while (v_y < 4u) { v_x = 0u; while (v_x < 4u) { v_x4y = ((v_x * 4u) | v_y); - v_i = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); + v_index = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); - self->private_data.f_buffer[(v_o + 0u)] = v_b[v_i]; - self->private_data.f_buffer[(v_o + 1u)] = v_g[v_i]; - self->private_data.f_buffer[(v_o + 2u)] = v_r[v_i]; + self->private_data.f_buffer[(v_o + 0u)] = v_b[v_index]; + self->private_data.f_buffer[(v_o + 1u)] = v_g[v_index]; + self->private_data.f_buffer[(v_o + 2u)] = v_r[v_index]; + self->private_data.f_buffer[(v_o + 3u)] = v_a[v_index]; v_x += 1u; } v_y += 1u; @@ -42396,6 +42632,7 @@ wuffs_etc2__decoder__decode_planar_mode( v_rp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_rh)) + ((uint32_t)(v_y * v_rv)))) + v_ro)); self->private_data.f_buffer[(v_o + 2u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_rp + 2u)) / 4u) & 1023u)]; v_x += 1u; + self->private_data.f_buffer[(v_o + 3u)] = 255u; } v_y += 1u; } @@ -42415,16 +42652,23 @@ wuffs_etc2__decoder__decode_half_block( uint32_t a_g, uint32_t a_b, bool a_flip, + bool a_transparent, bool a_second) { + uint32_t v_which = 0; uint32_t v_x0 = 0; uint32_t v_y0 = 0; uint32_t v_x = 0; uint32_t v_y = 0; uint32_t v_i = 0; uint32_t v_x4y = 0; + uint32_t v_index = 0; uint32_t v_modif = 0; uint32_t v_o = 0; + v_which = a_which; + if (a_transparent) { + v_which |= 8u; + } if ( ! a_second) { } else if (a_flip) { v_y0 = 2u; @@ -42440,16 +42684,66 @@ wuffs_etc2__decoder__decode_half_block( v_y = ((v_y0 + v_i) & 3u); } v_x4y = ((v_x * 4u) | v_y); - v_modif = WUFFS_ETC2__MODIFIERS[a_which][(((a_bits >> v_x4y) & 1u) | ((a_bits >> (v_x4y + 15u)) & 2u))]; + v_index = (((a_bits >> v_x4y) & 1u) | ((a_bits >> (v_x4y + 15u)) & 2u)); + v_modif = WUFFS_ETC2__MODIFIERS[v_which][v_index]; v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); - self->private_data.f_buffer[(v_o + 0u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_b + v_modif)) & 1023u)]; - self->private_data.f_buffer[(v_o + 1u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_g + v_modif)) & 1023u)]; - self->private_data.f_buffer[(v_o + 2u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_r + v_modif)) & 1023u)]; + if (a_transparent && (v_index == 2u)) { + self->private_data.f_buffer[(v_o + 0u)] = 0u; + self->private_data.f_buffer[(v_o + 1u)] = 0u; + self->private_data.f_buffer[(v_o + 2u)] = 0u; + self->private_data.f_buffer[(v_o + 3u)] = 0u; + } else { + self->private_data.f_buffer[(v_o + 0u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_b + v_modif)) & 1023u)]; + self->private_data.f_buffer[(v_o + 1u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_g + v_modif)) & 1023u)]; + self->private_data.f_buffer[(v_o + 2u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_r + v_modif)) & 1023u)]; + self->private_data.f_buffer[(v_o + 3u)] = 255u; + } v_i += 1u; } return wuffs_base__make_empty_struct(); } +// -------- func etc2.decoder.from_alphas_to_buffer + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__from_alphas_to_buffer( + wuffs_etc2__decoder* self) { + uint32_t v_bi = 0; + uint64_t v_alpha = 0; + uint32_t v_a0 = 0; + uint32_t v_multiplier = 0; + uint32_t v_which = 0; + uint32_t v_offset = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_shift = 0; + uint32_t v_delta = 0; + uint32_t v_o = 0; + + while (v_bi < self->private_impl.f_num_buffered_blocks) { + v_alpha = self->private_data.f_alphas[v_bi]; + v_a0 = ((uint32_t)((v_alpha >> 56u))); + v_multiplier = ((uint32_t)(((v_alpha >> 52u) & 15u))); + v_which = ((uint32_t)(((v_alpha >> 48u) & 15u))); + v_offset = (16u * v_bi); + v_y = 0u; + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_shift = ((((v_x ^ 3u) * 4u) | (v_y ^ 3u)) * 3u); + v_delta = ((uint32_t)(v_multiplier * WUFFS_ETC2__ALPHA_MODIFIERS[v_which][(7u & (v_alpha >> v_shift))])); + v_o = (v_offset + (v_x * 4u) + (v_y * 1024u)); + self->private_data.f_buffer[(v_o + 3u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(v_a0 + v_delta)) & 1023u)]; + v_x += 1u; + } + v_y += 1u; + } + v_bi += 1u; + } + return wuffs_base__make_empty_struct(); +} + // -------- func etc2.decoder.from_buffer_to_dst WUFFS_BASE__GENERATED_C_CODE diff --git a/std/etc2/decode_etc2.wuffs b/std/etc2/decode_etc2.wuffs index 0e01e590..11e903ca 100644 --- a/std/etc2/decode_etc2.wuffs +++ b/std/etc2/decode_etc2.wuffs @@ -22,9 +22,15 @@ // AOSP has a software implementation, used by its etc1tool program: // https://cs.android.com/android/platform/superproject/main/+/main:frameworks/native/opengl/libs/ETC1/etc1.cpp;l=200;drc=efb735f4d5a2f04550e33e8aa9485f906018fe4e // -// ETC2 (mandatory in OpenGL ES 3.0) extends ETC1 in a backwards-compatible way -// by re-purposing bit patterns that well-behaved encoders wouldn't emit. +// ETC2 (mandatory in OpenGL ES 3.0; see the 3.0 spec Appendix C.1 or the 3.2 +// spec Appendix C.2 "ETC Compressed Texture Image Formats") extends ETC1 in a +// backwards-compatible way by re-purposing bit patterns that well-behaved +// encoders wouldn't emit. It also uses 8 bytes per 4×4 block (0.5 bytes per +// pixel), unless producing 8-bit alpha (instead of no alpha or 1-bit alpha), +// in which case it's doubled to 16 bytes per 4×4 block (1 byte per pixel). // +// https://registry.khronos.org/OpenGL/specs/es/3.0/es_spec_3.0.pdf +// https://registry.khronos.org/OpenGL/specs/es/3.2/es_spec_3.2.pdf // https://www.khronos.org/assets/uploads/developers/library/2012-siggraph-opengl-es-bof/Ericsson-ETC2-SIGGRAPH_Aug12.pdf // https://www.graphicshardware.org/previous/www_2007/presentations/strom-etc2-gh07.pdf // https://github.com/Ericsson/ETCPACK @@ -55,6 +61,7 @@ pub struct decoder? implements base.image_decoder( swizzler : base.pixel_swizzler, util : base.utility, ) + ( + alphas : array[64] base.u64, colors : array[64] base.u64, // buffer holds 64 blocks. Each block is 4×4 pixels, 64 bytes. @@ -96,10 +103,16 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base. } c32 = args.src.read_u32le?() - if (c32 == '10\x00\x00'le) or // ETC1. - (c32 == '20\x00\x01'le) or // ETC2 RGB. - (c32 == '20\x00\x09'le) { // ETC2 sRGB. + if (c32 == '10\x00\x00'le) or // ETC1. + (c32 == '20\x00\x01'le) or // ETC2 RGB. + (c32 == '20\x00\x09'le) { // ETC2 sRGB. this.pixfmt = base.PIXEL_FORMAT__BGRX + } else if (c32 == '20\x00\x03'le) or // ETC2 RGBA8. + (c32 == '20\x00\x0A'le) { // ETC2 sRGBA8. + this.pixfmt = base.PIXEL_FORMAT__BGRA_NONPREMUL + } else if (c32 == '20\x00\x04'le) or // ETC2 RGBA1. + (c32 == '20\x00\x0B'le) { // ETC2 sRGBA1. + this.pixfmt = base.PIXEL_FORMAT__BGRA_BINARY } else if (c32 & 0xFFFF) == '20'le { return "#unsupported ETC2 file" } else { @@ -217,7 +230,6 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade this.dst_x = 0 this.dst_y = 0 - this.buffer[.. 4096].bulk_memset!(byte_value: 0xFF) remaining = ((this.width + 3) / 4) * ((this.height + 3) / 4) while remaining > 0 { @@ -229,6 +241,9 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade this.from_src_to_colors?(src: args.src) this.from_colors_to_buffer!() + if this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL { + this.from_alphas_to_buffer!() + } status = this.from_buffer_to_dst!(dst: args.dst) if not status.is_ok() { return status @@ -243,6 +258,9 @@ pri func decoder.from_src_to_colors?(src: base.io_reader) { while bi < this.num_buffered_blocks { assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks) + if this.pixfmt == base.PIXEL_FORMAT__BGRA_NONPREMUL { + this.alphas[bi] = args.src.read_u64be?() + } this.colors[bi] = args.src.read_u64be?() bi += 1 } @@ -257,13 +275,17 @@ pri func decoder.from_colors_to_buffer!() { var g1 : base.u32 var b0 : base.u32 var b1 : base.u32 + var diff : base.bool + var tran : base.bool var flip : base.bool while bi < this.num_buffered_blocks { assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks) color = this.colors[bi] - if (color & 0x2_0000_0000) == 0 { + diff = (color & 0x2_0000_0000) <> 0 + tran = (not diff) and (this.pixfmt == base.PIXEL_FORMAT__BGRA_BINARY) + if (not diff) and (this.pixfmt <> base.PIXEL_FORMAT__BGRA_BINARY) { // The high 32 bits of color: // // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec @@ -290,14 +312,15 @@ pri func decoder.from_colors_to_buffer!() { // // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex - // R0 r0 r0 r0 r0 R1 r1 r1 G0 g0 g0 g0 g0 G1 g1 g1 B0 b0 b0 b0 b0 B1 b1 b1 W0 w0 w0 W1 w1 w1 01 Fl + // R0 r0 r0 r0 r0 R1 r1 r1 G0 g0 g0 g0 g0 G1 g1 g1 B0 b0 b0 b0 b0 B1 b1 b1 W0 w0 w0 W1 w1 w1 .. Fl r0 = (0x1F & (color >> 0x3B)) as base.u32 r1 = r0 ~mod+ DIFFS[0x07 & (color >> 0x38)] if (r1 >> 5) <> 0 { this.decode_t_mode!( bits: color, - offset: 16 * bi) + offset: 16 * bi, + transparent: tran) bi += 1 continue } @@ -309,7 +332,8 @@ pri func decoder.from_colors_to_buffer!() { if (g1 >> 5) <> 0 { this.decode_h_mode!( bits: color, - offset: 16 * bi) + offset: 16 * bi, + transparent: tran) bi += 1 continue } @@ -338,6 +362,7 @@ pri func decoder.from_colors_to_buffer!() { g: g0, b: b0, flip: flip, + transparent: tran, second: false) this.decode_half_block!( bits: (color & 0xFFFF_FFFF) as base.u32, @@ -347,6 +372,7 @@ pri func decoder.from_colors_to_buffer!() { g: g1, b: b1, flip: flip, + transparent: tran, second: true) bi += 1 @@ -355,19 +381,21 @@ pri func decoder.from_colors_to_buffer!() { pri func decoder.decode_t_mode!( bits: base.u64, - offset: base.u32[..= 1008]) { + offset: base.u32[..= 1008], + transparent: base.bool) { var r : array[4] base.u8 var g : array[4] base.u8 var b : array[4] base.u8 + var a : array[4] base.u8 var which : base.u32[..= 7] var delta : base.u32 - var y : base.u32 - var x : base.u32 - var x4y : base.u32[..= 15] - var i : base.u32[..= 3] - var o : base.u32[..= 4092] + var y : base.u32 + var x : base.u32 + var x4y : base.u32[..= 15] + var index : base.u32[..= 3] + var o : base.u32[..= 4092] // Unjumble T-mode's 59 bits and convert from RGB444 to RGB888. // @@ -384,6 +412,7 @@ pri func decoder.decode_t_mode!( g[0] = (g[0] << 4) | g[0] b[0] = (0x0F & (args.bits >> 0x30)) as base.u8 b[0] = (b[0] << 4) | b[0] + a[0] = 0xFF r[2] = (0x0F & (args.bits >> 0x2C)) as base.u8 r[2] = (r[2] << 4) | r[2] @@ -391,8 +420,9 @@ pri func decoder.decode_t_mode!( g[2] = (g[2] << 4) | g[2] b[2] = (0x0F & (args.bits >> 0x24)) as base.u8 b[2] = (b[2] << 4) | b[2] + a[2] = 0xFF - // Modulate. + // Modulate and apply transparency. which = ((0x06 & (args.bits >> 0x21)) as base.u32) | ((0x01 & (args.bits >> 0x20)) as base.u32) @@ -401,10 +431,19 @@ pri func decoder.decode_t_mode!( r[1] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023] g[1] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023] b[1] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023] + a[1] = 0xFF r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023] g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023] b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023] + a[3] = 0xFF + + if args.transparent { + r[2] = 0 + g[2] = 0 + b[2] = 0 + a[2] = 0 + } // Paint the 4×4 block. @@ -414,12 +453,13 @@ pri func decoder.decode_t_mode!( inv y < 4, { x4y = (x * 4) | y - i = (((args.bits >> x4y) & 1) as base.u32) | + index = (((args.bits >> x4y) & 1) as base.u32) | (((args.bits >> (x4y + 15)) & 2) as base.u32) o = args.offset + (x * 4) + (y * 1024) - this.buffer[o + 0] = b[i] - this.buffer[o + 1] = g[i] - this.buffer[o + 2] = r[i] + this.buffer[o + 0] = b[index] + this.buffer[o + 1] = g[index] + this.buffer[o + 2] = r[index] + this.buffer[o + 3] = a[index] x += 1 } y += 1 @@ -428,21 +468,23 @@ pri func decoder.decode_t_mode!( pri func decoder.decode_h_mode!( bits: base.u64, - offset: base.u32[..= 1008]) { + offset: base.u32[..= 1008], + transparent: base.bool) { var r : array[4] base.u8 var g : array[4] base.u8 var b : array[4] base.u8 + var a : array[4] base.u8 var rgb0 : base.u32 var rgb2 : base.u32 var which : base.u32[..= 7] var delta : base.u32 - var y : base.u32 - var x : base.u32 - var x4y : base.u32[..= 15] - var i : base.u32[..= 3] - var o : base.u32[..= 4092] + var y : base.u32 + var x : base.u32 + var x4y : base.u32[..= 15] + var index : base.u32[..= 3] + var o : base.u32[..= 4092] // Unjumble H-mode's 58 bits (one of the 'which' bits is implied by order) // and convert from RGB444 to RGB888. @@ -469,7 +511,7 @@ pri func decoder.decode_h_mode!( b[2] = (0x0F & (args.bits >> 0x23)) as base.u8 b[2] = (b[2] << 4) | b[2] - // Modulate. + // Modulate and apply transparency. rgb0 = ((r[0] as base.u32) << 0x10) | ((g[0] as base.u32) << 0x08) | @@ -487,18 +529,29 @@ pri func decoder.decode_h_mode!( r[1] = CLAMP[((r[0] as base.u32) ~mod- delta) & 1023] g[1] = CLAMP[((g[0] as base.u32) ~mod- delta) & 1023] b[1] = CLAMP[((b[0] as base.u32) ~mod- delta) & 1023] + a[1] = 0xFF r[0] = CLAMP[((r[0] as base.u32) ~mod+ delta) & 1023] g[0] = CLAMP[((g[0] as base.u32) ~mod+ delta) & 1023] b[0] = CLAMP[((b[0] as base.u32) ~mod+ delta) & 1023] + a[0] = 0xFF r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023] g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023] b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023] + a[3] = 0xFF r[2] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023] g[2] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023] b[2] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023] + a[2] = 0xFF + + if args.transparent { + r[2] = 0 + g[2] = 0 + b[2] = 0 + a[2] = 0 + } // Paint the 4×4 block. @@ -508,12 +561,13 @@ pri func decoder.decode_h_mode!( inv y < 4, { x4y = (x * 4) | y - i = (((args.bits >> x4y) & 1) as base.u32) | + index = (((args.bits >> x4y) & 1) as base.u32) | (((args.bits >> (x4y + 15)) & 2) as base.u32) o = args.offset + (x * 4) + (y * 1024) - this.buffer[o + 0] = b[i] - this.buffer[o + 1] = g[i] - this.buffer[o + 2] = r[i] + this.buffer[o + 0] = b[index] + this.buffer[o + 1] = g[index] + this.buffer[o + 2] = r[index] + this.buffer[o + 3] = a[index] x += 1 } y += 1 @@ -606,6 +660,7 @@ pri func decoder.decode_planar_mode!( rp = ((x ~mod* rh) ~mod+ (y ~mod* rv)) ~mod+ ro this.buffer[o + 2] = CLAMP[((rp ~mod+ 2) / 4) & 1023] x += 1 + this.buffer[o + 3] = 0xFF } y += 1 } @@ -619,16 +674,24 @@ pri func decoder.decode_half_block!( g: base.u32, b: base.u32, flip: base.bool, + transparent: base.bool, second: base.bool) { + var which : base.u32[..= 15] var x0 : base.u32[..= 2] var y0 : base.u32[..= 2] var x : base.u32[..= 3] var y : base.u32[..= 3] var i : base.u32 var x4y : base.u32[..= 15] + var index : base.u32[..= 3] var modif : base.u32 var o : base.u32[..= 4092] + which = args.which + if args.transparent { + which |= 8 + } + if not args.second { // No-op. } else if args.flip { @@ -647,19 +710,71 @@ pri func decoder.decode_half_block!( } x4y = (x * 4) | y - modif = MODIFIERS[args.which][ - ((args.bits >> x4y) & 1) | - ((args.bits >> (x4y + 15)) & 2)] + index = ((args.bits >> x4y) & 1) | + ((args.bits >> (x4y + 15)) & 2) + modif = MODIFIERS[which][index] o = args.offset + (x * 4) + (y * 1024) - this.buffer[o + 0] = CLAMP[(args.b ~mod+ modif) & 1023] - this.buffer[o + 1] = CLAMP[(args.g ~mod+ modif) & 1023] - this.buffer[o + 2] = CLAMP[(args.r ~mod+ modif) & 1023] + if args.transparent and (index == 2) { + this.buffer[o + 0] = 0 + this.buffer[o + 1] = 0 + this.buffer[o + 2] = 0 + this.buffer[o + 3] = 0 + } else { + this.buffer[o + 0] = CLAMP[(args.b ~mod+ modif) & 1023] + this.buffer[o + 1] = CLAMP[(args.g ~mod+ modif) & 1023] + this.buffer[o + 2] = CLAMP[(args.r ~mod+ modif) & 1023] + this.buffer[o + 3] = 0xFF + } i += 1 } } +pri func decoder.from_alphas_to_buffer!() { + var bi : base.u32[..= 64] + var alpha : base.u64 + var a0 : base.u32 + var multiplier : base.u32[..= 15] + var which : base.u32[..= 15] + var offset : base.u32[..= 1008] + var y : base.u32 + var x : base.u32 + var shift : base.u32[..= 45] + var delta : base.u32 + var o : base.u32[..= 4092] + + while bi < this.num_buffered_blocks { + assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks) + alpha = this.alphas[bi] + + a0 = (alpha >> 56) as base.u32 + multiplier = ((alpha >> 52) & 0x0F) as base.u32 + which = ((alpha >> 48) & 0x0F) as base.u32 + + offset = 16 * bi + y = 0 + while y < 4, + inv bi < 64, + { + x = 0 + while x < 4, + inv bi < 64, + inv y < 4, + { + shift = (((x ^ 3) * 4) | (y ^ 3)) * 3 + delta = multiplier ~mod* ALPHA_MODIFIERS[which][7 & (alpha >> shift)] + o = offset + (x * 4) + (y * 1024) + this.buffer[o + 3] = CLAMP[(a0 ~mod+ delta) & 1023] + x += 1 + } + y += 1 + } + + bi += 1 + } +} + pri func decoder.from_buffer_to_dst!(dst: ptr base.pixel_buffer) base.status { var dst_pixfmt : base.pixel_format var dst_bits_per_pixel : base.u32[..= 256] @@ -801,19 +916,47 @@ pri const DIFFS : roarray[8] base.u32 = [ 0xFFFF_FFFF, ] -pri const MODIFIERS : roarray[8] roarray[4] base.u32 = [ - [0x0000_0002, 0x0000_0008, 0xFFFF_FFFE, 0xFFFF_FFF8], // [ -8, -2, 2, 8] re-ordered. - [0x0000_0005, 0x0000_0011, 0xFFFF_FFFB, 0xFFFF_FFEF], // [ -17, -5, 5, 17] re-ordered. - [0x0000_0009, 0x0000_001D, 0xFFFF_FFF7, 0xFFFF_FFE3], // [ -29, -9, 9, 29] re-ordered. - [0x0000_000D, 0x0000_002A, 0xFFFF_FFF3, 0xFFFF_FFD6], // [ -42, -13, 13, 42] re-ordered. - [0x0000_0012, 0x0000_003C, 0xFFFF_FFEE, 0xFFFF_FFC4], // [ -60, -18, 18, 60] re-ordered. - [0x0000_0018, 0x0000_0050, 0xFFFF_FFE8, 0xFFFF_FFB0], // [ -80, -24, 24, 80] re-ordered. - [0x0000_0021, 0x0000_006A, 0xFFFF_FFDF, 0xFFFF_FF96], // [-106, -33, 33, 106] re-ordered. - [0x0000_002F, 0x0000_00B7, 0xFFFF_FFD1, 0xFFFF_FF49], // [-183, -47, 47, 183] re-ordered. +pri const MODIFIERS : roarray[16] roarray[4] base.u32 = [ + [0x0000_0002, 0x0000_0008, 0xFFFF_FFFE, 0xFFFF_FFF8], // [ -8, -2, +2, +8] re-ordered. + [0x0000_0005, 0x0000_0011, 0xFFFF_FFFB, 0xFFFF_FFEF], // [ -17, -5, +5, +17] re-ordered. + [0x0000_0009, 0x0000_001D, 0xFFFF_FFF7, 0xFFFF_FFE3], // [ -29, -9, +9, +29] re-ordered. + [0x0000_000D, 0x0000_002A, 0xFFFF_FFF3, 0xFFFF_FFD6], // [ -42, -13, +13, +42] re-ordered. + [0x0000_0012, 0x0000_003C, 0xFFFF_FFEE, 0xFFFF_FFC4], // [ -60, -18, +18, +60] re-ordered. + [0x0000_0018, 0x0000_0050, 0xFFFF_FFE8, 0xFFFF_FFB0], // [ -80, -24, +24, +80] re-ordered. + [0x0000_0021, 0x0000_006A, 0xFFFF_FFDF, 0xFFFF_FF96], // [-106, -33, +33, +106] re-ordered. + [0x0000_002F, 0x0000_00B7, 0xFFFF_FFD1, 0xFFFF_FF49], // [-183, -47, +47, +183] re-ordered. + + [0x0000_0000, 0x0000_0008, 0x0000_0000, 0xFFFF_FFF8], // [ -8, 0, 0, +8] re-ordered. + [0x0000_0000, 0x0000_0011, 0x0000_0000, 0xFFFF_FFEF], // [ -17, 0, 0, +17] re-ordered. + [0x0000_0000, 0x0000_001D, 0x0000_0000, 0xFFFF_FFE3], // [ -29, 0, 0, +29] re-ordered. + [0x0000_0000, 0x0000_002A, 0x0000_0000, 0xFFFF_FFD6], // [ -42, 0, 0, +42] re-ordered. + [0x0000_0000, 0x0000_003C, 0x0000_0000, 0xFFFF_FFC4], // [ -60, 0, 0, +60] re-ordered. + [0x0000_0000, 0x0000_0050, 0x0000_0000, 0xFFFF_FFB0], // [ -80, 0, 0, +80] re-ordered. + [0x0000_0000, 0x0000_006A, 0x0000_0000, 0xFFFF_FF96], // [-106, 0, 0, +106] re-ordered. + [0x0000_0000, 0x0000_00B7, 0x0000_0000, 0xFFFF_FF49], // [-183, 0, 0, +183] re-ordered. ] pri const T_H_MODIFIERS : roarray[8] base.u8 = [3, 6, 11, 16, 23, 32, 41, 64] +pri const ALPHA_MODIFIERS : roarray[16] roarray[8] base.u32 = [ + [0xFFFF_FFFD, 0xFFFF_FFFA, 0xFFFF_FFF7, 0xFFFF_FFF1, 0x0000_0002, 0x0000_0005, 0x0000_0008, 0x0000_000E], // [-3, -6, -9, -15, +2, +5, +8, +14] + [0xFFFF_FFFD, 0xFFFF_FFF9, 0xFFFF_FFF6, 0xFFFF_FFF3, 0x0000_0002, 0x0000_0006, 0x0000_0009, 0x0000_000C], // [-3, -7, -10, -13, +2, +6, +9, +12] + [0xFFFF_FFFE, 0xFFFF_FFFB, 0xFFFF_FFF8, 0xFFFF_FFF3, 0x0000_0001, 0x0000_0004, 0x0000_0007, 0x0000_000C], // [-2, -5, -8, -13, +1, +4, +7, +12] + [0xFFFF_FFFE, 0xFFFF_FFFC, 0xFFFF_FFFA, 0xFFFF_FFF3, 0x0000_0001, 0x0000_0003, 0x0000_0005, 0x0000_000C], // [-2, -4, -6, -13, +1, +3, +5, +12] + [0xFFFF_FFFD, 0xFFFF_FFFA, 0xFFFF_FFF8, 0xFFFF_FFF4, 0x0000_0002, 0x0000_0005, 0x0000_0007, 0x0000_000B], // [-3, -6, -8, -12, +2, +5, +7, +11] + [0xFFFF_FFFD, 0xFFFF_FFF9, 0xFFFF_FFF7, 0xFFFF_FFF5, 0x0000_0002, 0x0000_0006, 0x0000_0008, 0x0000_000A], // [-3, -7, -9, -11, +2, +6, +8, +10] + [0xFFFF_FFFC, 0xFFFF_FFF9, 0xFFFF_FFF8, 0xFFFF_FFF5, 0x0000_0003, 0x0000_0006, 0x0000_0007, 0x0000_000A], // [-4, -7, -8, -11, +3, +6, +7, +10] + [0xFFFF_FFFD, 0xFFFF_FFFB, 0xFFFF_FFF8, 0xFFFF_FFF5, 0x0000_0002, 0x0000_0004, 0x0000_0007, 0x0000_000A], // [-3, -5, -8, -11, +2, +4, +7, +10] + [0xFFFF_FFFE, 0xFFFF_FFFA, 0xFFFF_FFF8, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0005, 0x0000_0007, 0x0000_0009], // [-2, -6, -8, -10, +1, +5, +7, +9] + [0xFFFF_FFFE, 0xFFFF_FFFB, 0xFFFF_FFF8, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0004, 0x0000_0007, 0x0000_0009], // [-2, -5, -8, -10, +1, +4, +7, +9] + [0xFFFF_FFFE, 0xFFFF_FFFC, 0xFFFF_FFF8, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0003, 0x0000_0007, 0x0000_0009], // [-2, -4, -8, -10, +1, +3, +7, +9] + [0xFFFF_FFFE, 0xFFFF_FFFB, 0xFFFF_FFF9, 0xFFFF_FFF6, 0x0000_0001, 0x0000_0004, 0x0000_0006, 0x0000_0009], // [-2, -5, -7, -10, +1, +4, +6, +9] + [0xFFFF_FFFD, 0xFFFF_FFFC, 0xFFFF_FFF9, 0xFFFF_FFF6, 0x0000_0002, 0x0000_0003, 0x0000_0006, 0x0000_0009], // [-3, -4, -7, -10, +2, +3, +6, +9] + [0xFFFF_FFFF, 0xFFFF_FFFE, 0xFFFF_FFFD, 0xFFFF_FFF6, 0x0000_0000, 0x0000_0001, 0x0000_0002, 0x0000_0009], // [-1, -2, -3, -10, +0, +1, +2, +9] + [0xFFFF_FFFC, 0xFFFF_FFFA, 0xFFFF_FFF8, 0xFFFF_FFF7, 0x0000_0003, 0x0000_0005, 0x0000_0007, 0x0000_0008], // [-4, -6, -8, -9, +3, +5, +7, +8] + [0xFFFF_FFFD, 0xFFFF_FFFB, 0xFFFF_FFF9, 0xFFFF_FFF7, 0x0000_0002, 0x0000_0004, 0x0000_0006, 0x0000_0008], // [-3, -5, -7, -9, +2, +4, +6, +8] +] + pri const CLAMP : roarray[1024] base.u8 = [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, diff --git a/test/c/std/wbmp.c b/test/c/std/wbmp.c index 1570b6e6..1aa176bd 100644 --- a/test/c/std/wbmp.c +++ b/test/c/std/wbmp.c @@ -349,6 +349,10 @@ test_wuffs_pixel_swizzler_swizzle() { .color = 0x55443300, .pixfmt_repr = WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL, }, + { + .color = 0xFF443300, + .pixfmt_repr = WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY, + }, { .color = 0xFF443300, .pixfmt_repr = WUFFS_BASE__PIXEL_FORMAT__BGRX, diff --git a/test/data/hippopotamus.masked-with-muybridge.etc2.bgra-binary.pkm b/test/data/hippopotamus.masked-with-muybridge.etc2.bgra-binary.pkm new file mode 100644 index 0000000000000000000000000000000000000000..80998517d26a8291092a6dae2837d3b30efe9acd GIT binary patch literal 520 zcmWIW_Ej)4U|?ZTVUPjg9Yw$FD!vFLu*@!Rt~Tbm`?^D8nah!mj@KPl$9T>haB<;L zeZ-Te>nyt25bY{*Ko^?D){&U&S z&$lgI?IP1{^`GI{1J-o*#vSJh{8-c38&17of54qoz;N!Yu%KW`i{jZgjs{%0HH!av z1bErPG*{UF?_hX+#=X?t+<;}}%9YFvp$v?ZKVJ>z`ClT)mL^v4z5JcKKz_O6|DK*T zoDmTW|Nk>Em<2j9{Qu6tpc)^^@c#~jkZpCf2BUrFiljp)-9GTMl<}R}z0KJ8jKk}h zySMS2;ohwj7?|JpA&-O2W!6juCI&vU)Kmq=&mCN!cB{DDQ+Qv`leXrBeEA!ODLhBR zcFaHHp1p5hu~|x&s_V~pum7D9Vt?JSd%Jt_>Aj)6Qmc)PzNfOglvf>b@afsYBW+Y( zzL}$>r)S>(eufRJKR?rzWSMfz4;f)}xK`^U95X0m%39gcW?in+c~fB9>6~k4*YI_S&pQ9lqT@aT1gKR`QtLUhYxM&NmqBUA zNlm8pp-_BigK}tGg{YtMhXJ*GPtbx4pcOkgm39X(bnpLv|I06Vr>Mo7 z-Hbc#cT8IML4V=@_5uE9gfhz28QvTE zcF+8}HgL!67tQRGjSoniebH06KT?&WBcPkTYn9lU2YN*_TN*r6Lh{uUvy77EH|*_c zP5YL{8O!tfjC+*;nx;9?w%yKMxpE~lLns5|MUhS3xxcRHP5yi}nCE|qVDX9R zpUtIz{%1=QEB;^p*sXKc{Ez$9o?YQcFHHq)#|6Zl05*ix$=OF`M$8@VJ974YT6yoBXT#7q6x>o*w{a^m`-cP$#y#5>a z_!Q1i3OVNXajj)`wvRaP!!_qst$nxNx}6)ec1y5-a!JMwsQH<@cKMd&^p#(S^7sCH z_xk@CVfHIf{_Bq2+ue&#@4X4-TSY~seoqNG`9Mfzk|)b726K0J%_BvQT?brur|Km= zTW*z{#a{06|N9n4zN%x#%9a;4H@7hMyKFdU;#ar)RDpg>ZLJS)H%IklvGBj!e&??J z_3qtchS?0WVea|$?%g9shWBq^?kUgx`TgVleS4=={IFm2OMYSAukS_g-Ww@yh`3_w z{6&A^<;$0q@7@hn+V1hgzWIl})4qNC9Pi$}nzq~M$Nr{Y@(XL{&P@yrjOg00@I~J1 zi+*!WPfu!S;H%Xq%&*uwU9sg}wQ5yby78`=2Mn+1I$g1KK6L1inwr||*_$G6$vWN8 fb$