mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
std/etc2: support transparency
This commit is contained in:
1 parent
2d80615a08
commit
96eda2ec0d
7 files changed
+627
-81
No files matched your search
@@ -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);
|
||||
|
||||
@@ -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
|
||||
|
||||
+190
-47
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
Binary file not shown.
Binary file not shown.
@@ -82,6 +82,8 @@ BAD c3c4bd65 test/data/hippopotamus.interlaced.truncated.gif
|
||||
BAD 7c6a771b test/data/hippopotamus.interlaced.truncated.png
|
||||
OK. 96bdbbb3 test/data/hippopotamus.jpeg
|
||||
OK. dcbb225a test/data/hippopotamus.lossless.webp
|
||||
OK. 45979d1b test/data/hippopotamus.masked-with-muybridge.etc2.bgra-binary.pkm
|
||||
OK. b51ed7e8 test/data/hippopotamus.masked-with-muybridge.etc2.bgra-nonpremul.pkm
|
||||
OK. d3bbed27 test/data/hippopotamus.masked-with-muybridge.gif
|
||||
OK. 7e6acf01 test/data/hippopotamus.masked-with-muybridge.png
|
||||
OK. dcbb225a test/data/hippopotamus.nie
|
||||
|
||||
Reference in new issue
Block a user