std/etc2: refactor decoder.from_src_to_buffer

This commit is contained in:
Nigel Tao committed 2024-08-18 10:07:58 +10:00
1 parent 7637982814
commit 2d80615a08
2 files changed
+186 -153

No files matched your search

+125 -101
View File
@@ -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
View File
@@ -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