mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-20 00:47:28 +01:00
std/etc2: refactor decoder.from_src_to_buffer
This commit is contained in:
1 parent
7637982814
commit
2d80615a08
2 files changed
+186
-153
No files matched your search
@@ -9116,10 +9116,9 @@ struct wuffs_etc2__decoder__struct {
|
||||
uint32_t f_pixfmt;
|
||||
uint32_t f_width;
|
||||
uint32_t f_height;
|
||||
uint32_t f_remaining_blocks;
|
||||
uint8_t f_call_sequence;
|
||||
bool f_srgb;
|
||||
uint32_t f_buffer_index;
|
||||
uint32_t f_num_buffered_blocks;
|
||||
uint32_t f_dst_x;
|
||||
uint32_t f_dst_y;
|
||||
wuffs_base__pixel_swizzler f_swizzler;
|
||||
@@ -9130,10 +9129,11 @@ struct wuffs_etc2__decoder__struct {
|
||||
uint32_t p_do_decode_frame_config;
|
||||
uint32_t p_decode_frame;
|
||||
uint32_t p_do_decode_frame;
|
||||
uint32_t p_from_src_to_buffer;
|
||||
uint32_t p_from_src_to_colors;
|
||||
} private_impl;
|
||||
|
||||
struct {
|
||||
uint64_t f_colors[64];
|
||||
uint8_t f_buffer[4096];
|
||||
|
||||
struct {
|
||||
@@ -9141,11 +9141,13 @@ struct wuffs_etc2__decoder__struct {
|
||||
uint16_t v_rounded_up_height;
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config;
|
||||
struct {
|
||||
uint32_t v_remaining;
|
||||
} s_do_decode_frame;
|
||||
struct {
|
||||
uint32_t v_bi;
|
||||
uint32_t v_bj;
|
||||
uint64_t scratch;
|
||||
} s_from_src_to_buffer;
|
||||
} s_from_src_to_colors;
|
||||
} private_data;
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -41189,10 +41191,15 @@ wuffs_etc2__decoder__do_decode_frame(
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_etc2__decoder__from_src_to_buffer(
|
||||
wuffs_etc2__decoder__from_src_to_colors(
|
||||
wuffs_etc2__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_etc2__decoder__from_colors_to_buffer(
|
||||
wuffs_etc2__decoder* self);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_etc2__decoder__decode_t_mode(
|
||||
@@ -41955,9 +41962,13 @@ wuffs_etc2__decoder__do_decode_frame(
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_remaining = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
|
||||
if (coro_susp_point) {
|
||||
v_remaining = self->private_data.s_do_decode_frame.v_remaining;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
@@ -41991,18 +42002,20 @@ 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);
|
||||
self->private_impl.f_remaining_blocks = (((self->private_impl.f_width + 3u) / 4u) * ((self->private_impl.f_height + 3u) / 4u));
|
||||
while (self->private_impl.f_remaining_blocks > 0u) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_etc2__decoder__from_src_to_buffer(self, a_src);
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (self->private_impl.f_remaining_blocks < self->private_impl.f_buffer_index) {
|
||||
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);
|
||||
if (v_remaining < self->private_impl.f_num_buffered_blocks) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__too_much_data);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_remaining_blocks -= self->private_impl.f_buffer_index;
|
||||
v_remaining -= self->private_impl.f_num_buffered_blocks;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_etc2__decoder__from_src_to_colors(self, a_src);
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
wuffs_etc2__decoder__from_colors_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;
|
||||
@@ -42025,31 +42038,23 @@ wuffs_etc2__decoder__do_decode_frame(
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_do_decode_frame.v_remaining = v_remaining;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func etc2.decoder.from_src_to_buffer
|
||||
// -------- func etc2.decoder.from_src_to_colors
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_etc2__decoder__from_src_to_buffer(
|
||||
wuffs_etc2__decoder__from_src_to_colors(
|
||||
wuffs_etc2__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_bi = 0;
|
||||
uint32_t v_bj = 0;
|
||||
uint64_t v_c64 = 0;
|
||||
uint32_t v_r0 = 0;
|
||||
uint32_t v_r1 = 0;
|
||||
uint32_t v_g0 = 0;
|
||||
uint32_t v_g1 = 0;
|
||||
uint32_t v_b0 = 0;
|
||||
uint32_t v_b1 = 0;
|
||||
bool v_flip = false;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -42062,16 +42067,14 @@ wuffs_etc2__decoder__from_src_to_buffer(
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_from_src_to_buffer;
|
||||
uint32_t coro_susp_point = self->private_impl.p_from_src_to_colors;
|
||||
if (coro_susp_point) {
|
||||
v_bi = self->private_data.s_from_src_to_buffer.v_bi;
|
||||
v_bj = self->private_data.s_from_src_to_buffer.v_bj;
|
||||
v_bi = self->private_data.s_from_src_to_colors.v_bi;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_bj = wuffs_base__u32__min(self->private_impl.f_remaining_blocks, 64u);
|
||||
while (v_bi < v_bj) {
|
||||
while (v_bi < self->private_impl.f_num_buffered_blocks) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
@@ -42079,14 +42082,14 @@ wuffs_etc2__decoder__from_src_to_buffer(
|
||||
t_0 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 8;
|
||||
} else {
|
||||
self->private_data.s_from_src_to_buffer.scratch = 0;
|
||||
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_buffer.scratch;
|
||||
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;
|
||||
@@ -42099,84 +42102,21 @@ wuffs_etc2__decoder__from_src_to_buffer(
|
||||
*scratch |= ((uint64_t)(num_bits_0));
|
||||
}
|
||||
}
|
||||
v_c64 = t_0;
|
||||
self->private_data.f_colors[v_bi] = t_0;
|
||||
}
|
||||
if ((v_c64 & 8589934592u) == 0u) {
|
||||
v_r0 = ((uint32_t)((15u & (v_c64 >> 60u))));
|
||||
v_r0 = ((v_r0 << 4u) | v_r0);
|
||||
v_r1 = ((uint32_t)((15u & (v_c64 >> 56u))));
|
||||
v_r1 = ((v_r1 << 4u) | v_r1);
|
||||
v_g0 = ((uint32_t)((15u & (v_c64 >> 52u))));
|
||||
v_g0 = ((v_g0 << 4u) | v_g0);
|
||||
v_g1 = ((uint32_t)((15u & (v_c64 >> 48u))));
|
||||
v_g1 = ((v_g1 << 4u) | v_g1);
|
||||
v_b0 = ((uint32_t)((15u & (v_c64 >> 44u))));
|
||||
v_b0 = ((v_b0 << 4u) | v_b0);
|
||||
v_b1 = ((uint32_t)((15u & (v_c64 >> 40u))));
|
||||
v_b1 = ((v_b1 << 4u) | v_b1);
|
||||
} else {
|
||||
v_r0 = ((uint32_t)((31u & (v_c64 >> 59u))));
|
||||
v_r1 = ((uint32_t)(v_r0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 56u))]));
|
||||
if ((v_r1 >> 5u) != 0u) {
|
||||
wuffs_etc2__decoder__decode_t_mode(self, v_c64, (16u * v_bi));
|
||||
v_bi += 1u;
|
||||
continue;
|
||||
}
|
||||
v_r0 = (((uint32_t)(v_r0 << 3u)) | (v_r0 >> 2u));
|
||||
v_r1 = (((uint32_t)(v_r1 << 3u)) | (v_r1 >> 2u));
|
||||
v_g0 = ((uint32_t)((31u & (v_c64 >> 51u))));
|
||||
v_g1 = ((uint32_t)(v_g0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 48u))]));
|
||||
if ((v_g1 >> 5u) != 0u) {
|
||||
wuffs_etc2__decoder__decode_h_mode(self, v_c64, (16u * v_bi));
|
||||
v_bi += 1u;
|
||||
continue;
|
||||
}
|
||||
v_g0 = (((uint32_t)(v_g0 << 3u)) | (v_g0 >> 2u));
|
||||
v_g1 = (((uint32_t)(v_g1 << 3u)) | (v_g1 >> 2u));
|
||||
v_b0 = ((uint32_t)((31u & (v_c64 >> 43u))));
|
||||
v_b1 = ((uint32_t)(v_b0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 40u))]));
|
||||
if ((v_b1 >> 5u) != 0u) {
|
||||
wuffs_etc2__decoder__decode_planar_mode(self, v_c64, (16u * v_bi));
|
||||
v_bi += 1u;
|
||||
continue;
|
||||
}
|
||||
v_b0 = (((uint32_t)(v_b0 << 3u)) | (v_b0 >> 2u));
|
||||
v_b1 = (((uint32_t)(v_b1 << 3u)) | (v_b1 >> 2u));
|
||||
}
|
||||
v_flip = ((v_c64 & 4294967296u) != 0u);
|
||||
wuffs_etc2__decoder__decode_half_block(self,
|
||||
((uint32_t)(v_c64)),
|
||||
(16u * v_bi),
|
||||
((uint32_t)(((v_c64 >> 37u) & 7u))),
|
||||
v_r0,
|
||||
v_g0,
|
||||
v_b0,
|
||||
v_flip,
|
||||
false);
|
||||
wuffs_etc2__decoder__decode_half_block(self,
|
||||
((uint32_t)(v_c64)),
|
||||
(16u * v_bi),
|
||||
((uint32_t)(((v_c64 >> 34u) & 7u))),
|
||||
v_r1,
|
||||
v_g1,
|
||||
v_b1,
|
||||
v_flip,
|
||||
true);
|
||||
v_bi += 1u;
|
||||
}
|
||||
self->private_impl.f_buffer_index = v_bi;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_from_src_to_buffer = 0;
|
||||
self->private_impl.p_from_src_to_colors = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_from_src_to_buffer = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_from_src_to_buffer.v_bi = v_bi;
|
||||
self->private_data.s_from_src_to_buffer.v_bj = v_bj;
|
||||
self->private_impl.p_from_src_to_colors = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_from_src_to_colors.v_bi = v_bi;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -42187,6 +42127,90 @@ wuffs_etc2__decoder__from_src_to_buffer(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func etc2.decoder.from_colors_to_buffer
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_etc2__decoder__from_colors_to_buffer(
|
||||
wuffs_etc2__decoder* self) {
|
||||
uint32_t v_bi = 0;
|
||||
uint64_t v_color = 0;
|
||||
uint32_t v_r0 = 0;
|
||||
uint32_t v_r1 = 0;
|
||||
uint32_t v_g0 = 0;
|
||||
uint32_t v_g1 = 0;
|
||||
uint32_t v_b0 = 0;
|
||||
uint32_t v_b1 = 0;
|
||||
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_r0 = ((uint32_t)((15u & (v_color >> 60u))));
|
||||
v_r0 = ((v_r0 << 4u) | v_r0);
|
||||
v_r1 = ((uint32_t)((15u & (v_color >> 56u))));
|
||||
v_r1 = ((v_r1 << 4u) | v_r1);
|
||||
v_g0 = ((uint32_t)((15u & (v_color >> 52u))));
|
||||
v_g0 = ((v_g0 << 4u) | v_g0);
|
||||
v_g1 = ((uint32_t)((15u & (v_color >> 48u))));
|
||||
v_g1 = ((v_g1 << 4u) | v_g1);
|
||||
v_b0 = ((uint32_t)((15u & (v_color >> 44u))));
|
||||
v_b0 = ((v_b0 << 4u) | v_b0);
|
||||
v_b1 = ((uint32_t)((15u & (v_color >> 40u))));
|
||||
v_b1 = ((v_b1 << 4u) | v_b1);
|
||||
} else {
|
||||
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));
|
||||
v_bi += 1u;
|
||||
continue;
|
||||
}
|
||||
v_r0 = (((uint32_t)(v_r0 << 3u)) | (v_r0 >> 2u));
|
||||
v_r1 = (((uint32_t)(v_r1 << 3u)) | (v_r1 >> 2u));
|
||||
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));
|
||||
v_bi += 1u;
|
||||
continue;
|
||||
}
|
||||
v_g0 = (((uint32_t)(v_g0 << 3u)) | (v_g0 >> 2u));
|
||||
v_g1 = (((uint32_t)(v_g1 << 3u)) | (v_g1 >> 2u));
|
||||
v_b0 = ((uint32_t)((31u & (v_color >> 43u))));
|
||||
v_b1 = ((uint32_t)(v_b0 + WUFFS_ETC2__DIFFS[(7u & (v_color >> 40u))]));
|
||||
if ((v_b1 >> 5u) != 0u) {
|
||||
wuffs_etc2__decoder__decode_planar_mode(self, v_color, (16u * v_bi));
|
||||
v_bi += 1u;
|
||||
continue;
|
||||
}
|
||||
v_b0 = (((uint32_t)(v_b0 << 3u)) | (v_b0 >> 2u));
|
||||
v_b1 = (((uint32_t)(v_b1 << 3u)) | (v_b1 >> 2u));
|
||||
}
|
||||
v_flip = ((v_color & 4294967296u) != 0u);
|
||||
wuffs_etc2__decoder__decode_half_block(self,
|
||||
((uint32_t)(v_color)),
|
||||
(16u * v_bi),
|
||||
((uint32_t)(((v_color >> 37u) & 7u))),
|
||||
v_r0,
|
||||
v_g0,
|
||||
v_b0,
|
||||
v_flip,
|
||||
false);
|
||||
wuffs_etc2__decoder__decode_half_block(self,
|
||||
((uint32_t)(v_color)),
|
||||
(16u * v_bi),
|
||||
((uint32_t)(((v_color >> 34u) & 7u))),
|
||||
v_r1,
|
||||
v_g1,
|
||||
v_b1,
|
||||
v_flip,
|
||||
true);
|
||||
v_bi += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func etc2.decoder.decode_t_mode
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -42456,7 +42480,7 @@ wuffs_etc2__decoder__from_buffer_to_dst(
|
||||
v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u);
|
||||
v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * v_dst_bytes_per_pixel)));
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
|
||||
while (v_bi < self->private_impl.f_buffer_index) {
|
||||
while (v_bi < self->private_impl.f_num_buffered_blocks) {
|
||||
if (self->private_impl.f_width <= self->private_impl.f_dst_x) {
|
||||
self->private_impl.f_dst_x = 0u;
|
||||
self->private_impl.f_dst_y += 4u;
|
||||
|
||||
+61
-52
@@ -41,16 +41,13 @@ pub struct decoder? implements base.image_decoder(
|
||||
width : base.u32[..= 0xFFFF],
|
||||
height : base.u32[..= 0xFFFF],
|
||||
|
||||
remaining_blocks : base.u32[..= 0x1000_0000],
|
||||
|
||||
// The call sequence state machine is discussed in
|
||||
// (/doc/std/image-decoders-call-sequence.md).
|
||||
call_sequence : base.u8,
|
||||
|
||||
srgb : base.bool,
|
||||
|
||||
// buffer_index is measured in blocks.
|
||||
buffer_index : base.u32[..= 64],
|
||||
num_buffered_blocks : base.u32[..= 64],
|
||||
|
||||
dst_x : base.u32,
|
||||
dst_y : base.u32,
|
||||
@@ -58,6 +55,8 @@ pub struct decoder? implements base.image_decoder(
|
||||
swizzler : base.pixel_swizzler,
|
||||
util : base.utility,
|
||||
) + (
|
||||
colors : array[64] base.u64,
|
||||
|
||||
// buffer holds 64 blocks. Each block is 4×4 pixels, 64 bytes.
|
||||
buffer : array[4096] base.u8,
|
||||
)
|
||||
@@ -195,7 +194,8 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) {
|
||||
var status : base.status
|
||||
var remaining : base.u32[..= 0x1000_0000]
|
||||
var status : base.status
|
||||
|
||||
if this.call_sequence == 0x40 {
|
||||
// No-op.
|
||||
@@ -219,13 +219,16 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
this.dst_y = 0
|
||||
this.buffer[.. 4096].bulk_memset!(byte_value: 0xFF)
|
||||
|
||||
this.remaining_blocks = ((this.width + 3) / 4) * ((this.height + 3) / 4)
|
||||
while this.remaining_blocks > 0 {
|
||||
this.from_src_to_buffer?(src: args.src)
|
||||
if this.remaining_blocks < this.buffer_index {
|
||||
remaining = ((this.width + 3) / 4) * ((this.height + 3) / 4)
|
||||
while remaining > 0 {
|
||||
this.num_buffered_blocks = remaining.min(no_more_than: 64)
|
||||
if remaining < this.num_buffered_blocks {
|
||||
return base."#too much data"
|
||||
}
|
||||
this.remaining_blocks -= this.buffer_index
|
||||
remaining -= this.num_buffered_blocks
|
||||
|
||||
this.from_src_to_colors?(src: args.src)
|
||||
this.from_colors_to_buffer!()
|
||||
status = this.from_buffer_to_dst!(dst: args.dst)
|
||||
if not status.is_ok() {
|
||||
return status
|
||||
@@ -235,57 +238,65 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
this.call_sequence = 0x60
|
||||
}
|
||||
|
||||
pri func decoder.from_src_to_buffer?(src: base.io_reader) {
|
||||
var bi : base.u32[..= 64]
|
||||
var bj : base.u32[..= 64]
|
||||
var c64 : base.u64
|
||||
var r0 : base.u32
|
||||
var r1 : base.u32
|
||||
var g0 : base.u32
|
||||
var g1 : base.u32
|
||||
var b0 : base.u32
|
||||
var b1 : base.u32
|
||||
var flip : base.bool
|
||||
pri func decoder.from_src_to_colors?(src: base.io_reader) {
|
||||
var bi : base.u32[..= 64]
|
||||
|
||||
bj = this.remaining_blocks.min(no_more_than: 64)
|
||||
while bi < bj {
|
||||
assert bi < 64 via "a < b: a < c; c <= b"(c: bj)
|
||||
c64 = args.src.read_u64be?()
|
||||
while bi < this.num_buffered_blocks {
|
||||
assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks)
|
||||
this.colors[bi] = args.src.read_u64be?()
|
||||
bi += 1
|
||||
}
|
||||
}
|
||||
|
||||
if (c64 & 0x2_0000_0000) == 0 {
|
||||
// The high 32 bits of c64:
|
||||
pri func decoder.from_colors_to_buffer!() {
|
||||
var bi : base.u32[..= 64]
|
||||
var color : base.u64
|
||||
var r0 : base.u32
|
||||
var r1 : base.u32
|
||||
var g0 : base.u32
|
||||
var g1 : base.u32
|
||||
var b0 : base.u32
|
||||
var b1 : base.u32
|
||||
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 {
|
||||
// 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
|
||||
// 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 R1 r1 r1 r1 G0 g0 g0 g0 G1 g1 g1 g1 B0 b0 b0 b0 B1 b1 b1 b1 W0 w0 w0 W1 w1 w1 00 Fl
|
||||
|
||||
r0 = (0x0F & (c64 >> 0x3C)) as base.u32
|
||||
r0 = (0x0F & (color >> 0x3C)) as base.u32
|
||||
r0 = (r0 << 4) | r0
|
||||
r1 = (0x0F & (c64 >> 0x38)) as base.u32
|
||||
r1 = (0x0F & (color >> 0x38)) as base.u32
|
||||
r1 = (r1 << 4) | r1
|
||||
|
||||
g0 = (0x0F & (c64 >> 0x34)) as base.u32
|
||||
g0 = (0x0F & (color >> 0x34)) as base.u32
|
||||
g0 = (g0 << 4) | g0
|
||||
g1 = (0x0F & (c64 >> 0x30)) as base.u32
|
||||
g1 = (0x0F & (color >> 0x30)) as base.u32
|
||||
g1 = (g1 << 4) | g1
|
||||
|
||||
b0 = (0x0F & (c64 >> 0x2C)) as base.u32
|
||||
b0 = (0x0F & (color >> 0x2C)) as base.u32
|
||||
b0 = (b0 << 4) | b0
|
||||
b1 = (0x0F & (c64 >> 0x28)) as base.u32
|
||||
b1 = (0x0F & (color >> 0x28)) as base.u32
|
||||
b1 = (b1 << 4) | b1
|
||||
|
||||
} else {
|
||||
// The high 32 bits of c64 (unless ETC2's T / H / Planar modes):
|
||||
// The high 32 bits of color (unless ETC2's T / H / Planar modes):
|
||||
//
|
||||
// 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 = (0x1F & (c64 >> 0x3B)) as base.u32
|
||||
r1 = r0 ~mod+ DIFFS[0x07 & (c64 >> 0x38)]
|
||||
r0 = (0x1F & (color >> 0x3B)) as base.u32
|
||||
r1 = r0 ~mod+ DIFFS[0x07 & (color >> 0x38)]
|
||||
if (r1 >> 5) <> 0 {
|
||||
this.decode_t_mode!(
|
||||
bits: c64,
|
||||
bits: color,
|
||||
offset: 16 * bi)
|
||||
bi += 1
|
||||
continue
|
||||
@@ -293,11 +304,11 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
|
||||
r0 = (r0 ~mod<< 3) | (r0 >> 2)
|
||||
r1 = (r1 ~mod<< 3) | (r1 >> 2)
|
||||
|
||||
g0 = (0x1F & (c64 >> 0x33)) as base.u32
|
||||
g1 = g0 ~mod+ DIFFS[0x07 & (c64 >> 0x30)]
|
||||
g0 = (0x1F & (color >> 0x33)) as base.u32
|
||||
g1 = g0 ~mod+ DIFFS[0x07 & (color >> 0x30)]
|
||||
if (g1 >> 5) <> 0 {
|
||||
this.decode_h_mode!(
|
||||
bits: c64,
|
||||
bits: color,
|
||||
offset: 16 * bi)
|
||||
bi += 1
|
||||
continue
|
||||
@@ -305,11 +316,11 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
|
||||
g0 = (g0 ~mod<< 3) | (g0 >> 2)
|
||||
g1 = (g1 ~mod<< 3) | (g1 >> 2)
|
||||
|
||||
b0 = (0x1F & (c64 >> 0x2B)) as base.u32
|
||||
b1 = b0 ~mod+ DIFFS[0x07 & (c64 >> 0x28)]
|
||||
b0 = (0x1F & (color >> 0x2B)) as base.u32
|
||||
b1 = b0 ~mod+ DIFFS[0x07 & (color >> 0x28)]
|
||||
if (b1 >> 5) <> 0 {
|
||||
this.decode_planar_mode!(
|
||||
bits: c64,
|
||||
bits: color,
|
||||
offset: 16 * bi)
|
||||
bi += 1
|
||||
continue
|
||||
@@ -318,20 +329,20 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
|
||||
b1 = (b1 ~mod<< 3) | (b1 >> 2)
|
||||
}
|
||||
|
||||
flip = (c64 & 0x1_0000_0000) <> 0
|
||||
flip = (color & 0x1_0000_0000) <> 0
|
||||
this.decode_half_block!(
|
||||
bits: (c64 & 0xFFFF_FFFF) as base.u32,
|
||||
bits: (color & 0xFFFF_FFFF) as base.u32,
|
||||
offset: 16 * bi,
|
||||
which: ((c64 >> 0x25) & 7) as base.u32,
|
||||
which: ((color >> 0x25) & 7) as base.u32,
|
||||
r: r0,
|
||||
g: g0,
|
||||
b: b0,
|
||||
flip: flip,
|
||||
second: false)
|
||||
this.decode_half_block!(
|
||||
bits: (c64 & 0xFFFF_FFFF) as base.u32,
|
||||
bits: (color & 0xFFFF_FFFF) as base.u32,
|
||||
offset: 16 * bi,
|
||||
which: ((c64 >> 0x22) & 7) as base.u32,
|
||||
which: ((color >> 0x22) & 7) as base.u32,
|
||||
r: r1,
|
||||
g: g1,
|
||||
b: b1,
|
||||
@@ -340,8 +351,6 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
|
||||
|
||||
bi += 1
|
||||
}
|
||||
|
||||
this.buffer_index = bi
|
||||
}
|
||||
|
||||
pri func decoder.decode_t_mode!(
|
||||
@@ -678,8 +687,8 @@ pri func decoder.from_buffer_to_dst!(dst: ptr base.pixel_buffer) base.status {
|
||||
dst_bytes_per_row = (this.width * dst_bytes_per_pixel) as base.u64
|
||||
tab = args.dst.plane(p: 0)
|
||||
|
||||
while bi < this.buffer_index {
|
||||
assert bi < 64 via "a < b: a < c; c <= b"(c: this.buffer_index)
|
||||
while bi < this.num_buffered_blocks {
|
||||
assert bi < 64 via "a < b: a < c; c <= b"(c: this.num_buffered_blocks)
|
||||
|
||||
if this.width <= this.dst_x {
|
||||
this.dst_x = 0
|
||||
|
||||
Reference in new issue
Block a user