std/handsum: implement do_decode_frame

This commit is contained in:
Nigel Tao committed 2025-02-24 22:16:08 +11:00
1 parent 43a6814dfe
commit b6be81a83b
4 files changed
+1304 -38

No files matched your search

+674 -25
View File
@@ -10637,6 +10637,8 @@ struct wuffs_handsum__decoder__struct {
uint32_t f_width;
uint32_t f_height;
uint8_t f_call_sequence;
uint16_t f_bit_offset;
uint16_t f_coeffs[40];
wuffs_base__pixel_swizzler f_swizzler;
uint32_t p_decode_image_config;
@@ -10648,11 +10650,15 @@ struct wuffs_handsum__decoder__struct {
} private_impl;
struct {
uint8_t f_bits[64];
uint8_t f_buffers[2][32][128];
struct {
uint64_t scratch;
} s_do_decode_image_config;
struct {
uint32_t v_num_read;
} s_do_decode_frame;
} private_data;
#ifdef __cplusplus
@@ -48958,6 +48964,187 @@ const char wuffs_handsum__error__unsupported_handsum_file[] = "#handsum: unsuppo
// ---------------- Private Consts
static const uint8_t
WUFFS_HANDSUM__CLAMP_7[32] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u,
7u, 7u, 7u, 7u, 7u, 7u, 7u, 7u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_HANDSUM__CLAMP_15[64] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u,
8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u,
15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u,
15u, 15u, 15u, 15u, 15u, 15u, 15u, 15u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
};
static const uint8_t
WUFFS_HANDSUM__ZIGZAG[15] WUFFS_BASE__POTENTIALLY_UNUSED = {
0u, 1u, 8u, 16u, 9u, 2u, 3u, 10u,
17u, 24u, 32u, 25u, 18u, 11u, 4u,
};
static const uint8_t
WUFFS_HANDSUM__SMOOTHING_PAIRS[56] WUFFS_BASE__POTENTIALLY_UNUSED = {
7u, 8u, 23u, 24u, 39u, 40u, 55u, 56u,
71u, 72u, 87u, 88u, 103u, 104u, 112u, 128u,
113u, 129u, 114u, 130u, 115u, 131u, 116u, 132u,
117u, 133u, 118u, 134u, 121u, 137u, 122u, 138u,
123u, 139u, 124u, 140u, 125u, 141u, 126u, 142u,
127u, 143u, 151u, 152u, 167u, 168u, 183u, 184u,
199u, 200u, 215u, 216u, 231u, 232u, 247u, 248u,
};
#define WUFFS_HANDSUM__FIXED_POINT_HALF 32768u
#define WUFFS_HANDSUM__FIXED_POINT_INV_2_SQRT_2 23170u
static const uint32_t
WUFFS_HANDSUM__COSINES[32] WUFFS_BASE__POTENTIALLY_UNUSED = {
65536u, 64276u, 60547u, 54491u, 46340u, 36409u, 25079u, 12785u,
0u, 4294954511u, 4294942217u, 4294930887u, 4294920956u, 4294912805u, 4294906749u, 4294903020u,
4294901760u, 4294903020u, 4294906749u, 4294912805u, 4294920956u, 4294930887u, 4294942217u, 4294954511u,
0u, 12785u, 25079u, 36409u, 46340u, 54491u, 60547u, 64276u,
};
static const uint8_t
WUFFS_HANDSUM__BIAS_AND_CLAMP[1024] WUFFS_BASE__POTENTIALLY_UNUSED = {
128u, 129u, 130u, 131u, 132u, 133u, 134u, 135u,
136u, 137u, 138u, 139u, 140u, 141u, 142u, 143u,
144u, 145u, 146u, 147u, 148u, 149u, 150u, 151u,
152u, 153u, 154u, 155u, 156u, 157u, 158u, 159u,
160u, 161u, 162u, 163u, 164u, 165u, 166u, 167u,
168u, 169u, 170u, 171u, 172u, 173u, 174u, 175u,
176u, 177u, 178u, 179u, 180u, 181u, 182u, 183u,
184u, 185u, 186u, 187u, 188u, 189u, 190u, 191u,
192u, 193u, 194u, 195u, 196u, 197u, 198u, 199u,
200u, 201u, 202u, 203u, 204u, 205u, 206u, 207u,
208u, 209u, 210u, 211u, 212u, 213u, 214u, 215u,
216u, 217u, 218u, 219u, 220u, 221u, 222u, 223u,
224u, 225u, 226u, 227u, 228u, 229u, 230u, 231u,
232u, 233u, 234u, 235u, 236u, 237u, 238u, 239u,
240u, 241u, 242u, 243u, 244u, 245u, 246u, 247u,
248u, 249u, 250u, 251u, 252u, 253u, 254u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u,
8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u,
16u, 17u, 18u, 19u, 20u, 21u, 22u, 23u,
24u, 25u, 26u, 27u, 28u, 29u, 30u, 31u,
32u, 33u, 34u, 35u, 36u, 37u, 38u, 39u,
40u, 41u, 42u, 43u, 44u, 45u, 46u, 47u,
48u, 49u, 50u, 51u, 52u, 53u, 54u, 55u,
56u, 57u, 58u, 59u, 60u, 61u, 62u, 63u,
64u, 65u, 66u, 67u, 68u, 69u, 70u, 71u,
72u, 73u, 74u, 75u, 76u, 77u, 78u, 79u,
80u, 81u, 82u, 83u, 84u, 85u, 86u, 87u,
88u, 89u, 90u, 91u, 92u, 93u, 94u, 95u,
96u, 97u, 98u, 99u, 100u, 101u, 102u, 103u,
104u, 105u, 106u, 107u, 108u, 109u, 110u, 111u,
112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u,
120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u,
};
// ---------------- Private Initializer Prototypes
// ---------------- Private Function Prototypes
@@ -48987,10 +49174,47 @@ wuffs_handsum__decoder__do_decode_frame(
wuffs_base__decode_frame_options* a_opts);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_handsum__decoder__from_src_to_pixels(
static wuffs_base__empty_struct
wuffs_handsum__decoder__decode_block(
wuffs_handsum__decoder* self,
wuffs_base__io_buffer* a_src);
uint32_t a_which,
uint32_t a_y_offset,
uint32_t a_x_offset);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__decode_coeffs(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__smooth_luma_block_seams(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__upsample_chroma(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__upsample_bgr(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__convert_ycc_to_bgr(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__scale_1d_horizontal(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__scale_1d_vertical(
wuffs_handsum__decoder* self);
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
@@ -49569,15 +49793,37 @@ wuffs_handsum__decoder__do_decode_frame(
wuffs_base__status status = wuffs_base__make_status(NULL);
wuffs_base__status v_status = wuffs_base__make_status(NULL);
uint32_t v_num_read = 0;
uint32_t v_which = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
if (a_src && a_src->data.ptr) {
io0_a_src = a_src->data.ptr;
io1_a_src = io0_a_src + a_src->meta.ri;
iop_a_src = io1_a_src;
io2_a_src = io0_a_src + a_src->meta.wi;
}
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
if (coro_susp_point) {
v_num_read = self->private_data.s_do_decode_frame.v_num_read;
}
switch (coro_susp_point) {
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
if (self->private_impl.f_call_sequence == 64u) {
} else if (self->private_impl.f_call_sequence < 64u) {
if (a_src) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
status = wuffs_handsum__decoder__do_decode_frame_config(self, NULL, a_src);
if (a_src) {
iop_a_src = a_src->data.ptr + a_src->meta.ri;
}
if (status.repr) {
goto suspend;
}
@@ -49601,12 +49847,34 @@ wuffs_handsum__decoder__do_decode_frame(
}
goto ok;
}
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
status = wuffs_handsum__decoder__from_src_to_pixels(self, a_src);
if (status.repr) {
goto suspend;
while (v_num_read < 45u) {
v_num_read += wuffs_private_impl__io_reader__limited_copy_u32_to_slice(
&iop_a_src, io2_a_src,(45u - v_num_read), wuffs_base__make_slice_u8_ij(self->private_data.f_bits, v_num_read, 64));
if (v_num_read < 45u) {
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2);
}
}
v_status = wuffs_handsum__decoder__from_pixels_to_dst(self, a_dst, 0u);
self->private_impl.f_bit_offset = 0u;
wuffs_handsum__decoder__decode_block(self, 0u, 0u, 0u);
wuffs_handsum__decoder__decode_block(self, 0u, 0u, 32u);
wuffs_handsum__decoder__decode_block(self, 0u, 8u, 0u);
wuffs_handsum__decoder__decode_block(self, 0u, 8u, 32u);
wuffs_handsum__decoder__decode_block(self, 1u, 0u, 1u);
wuffs_handsum__decoder__decode_block(self, 1u, 0u, 2u);
wuffs_handsum__decoder__smooth_luma_block_seams(self);
wuffs_handsum__decoder__upsample_chroma(self);
wuffs_handsum__decoder__convert_ycc_to_bgr(self);
wuffs_handsum__decoder__upsample_bgr(self);
v_which = 1u;
if (self->private_impl.f_width < 32u) {
v_which = 0u;
wuffs_handsum__decoder__scale_1d_horizontal(self);
} else if (self->private_impl.f_height < 32u) {
v_which = 0u;
wuffs_handsum__decoder__scale_1d_vertical(self);
}
v_status = wuffs_handsum__decoder__from_pixels_to_dst(self, a_dst, v_which);
if ( ! wuffs_base__status__is_ok(&v_status)) {
status = v_status;
if (wuffs_base__status__is_error(&status)) {
@@ -49627,42 +49895,423 @@ wuffs_handsum__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_num_read = v_num_read;
goto exit;
exit:
if (a_src && a_src->data.ptr) {
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
}
return status;
}
// -------- func handsum.decoder.from_src_to_pixels
// -------- func handsum.decoder.decode_block
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__status
wuffs_handsum__decoder__from_src_to_pixels(
static wuffs_base__empty_struct
wuffs_handsum__decoder__decode_block(
wuffs_handsum__decoder* self,
wuffs_base__io_buffer* a_src) {
wuffs_base__status status = wuffs_base__make_status(NULL);
uint32_t a_which,
uint32_t a_y_offset,
uint32_t a_x_offset) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint32_t v_v = 0;
uint32_t v_u = 0;
uint64_t v_alphas_sum_32 = 0;
uint64_t v_half_alpha_v_16 = 0;
uint64_t v_half_alpha_u_16 = 0;
uint64_t v_alphas_16 = 0;
uint64_t v_c_32 = 0;
uint64_t v_c_16 = 0;
uint64_t v_result_0 = 0;
wuffs_handsum__decoder__decode_coeffs(self);
v_y = 0u;
while (v_y < 32u) {
while (v_y < 8u) {
v_x = 0u;
while (v_x < 32u) {
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 0u)] = ((uint8_t)((v_x * 8u)));
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 1u)] = ((uint8_t)((v_y * 8u)));
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 2u)] = 0u;
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 3u)] = 255u;
while (v_x < 8u) {
v_alphas_sum_32 = 0u;
v_v = 0u;
while (v_v < 5u) {
v_half_alpha_v_16 = ((uint64_t)(23170u));
if (v_v != 0u) {
v_half_alpha_v_16 = ((uint64_t)(32768u));
}
v_u = 0u;
while (v_u < 5u) {
v_half_alpha_u_16 = ((uint64_t)(23170u));
if (v_u != 0u) {
v_half_alpha_u_16 = ((uint64_t)(32768u));
}
v_alphas_16 = wuffs_base__utility__sign_extend_rshift_u64(((uint64_t)(((uint64_t)(v_half_alpha_v_16 * v_half_alpha_u_16)) + 32768u)), 16u);
v_c_32 = ((uint64_t)(wuffs_base__utility__sign_extend_convert_u32_u64(WUFFS_HANDSUM__COSINES[((((2u * v_x) + 1u) * v_u) & 31u)]) * wuffs_base__utility__sign_extend_convert_u32_u64(WUFFS_HANDSUM__COSINES[((((2u * v_y) + 1u) * v_v) & 31u)])));
v_c_16 = wuffs_base__utility__sign_extend_rshift_u64(((uint64_t)(v_c_32 + 32768u)), 16u);
v_alphas_sum_32 += ((uint64_t)(((uint64_t)(v_alphas_16 * v_c_16)) * wuffs_base__utility__sign_extend_convert_u16_u64(self->private_impl.f_coeffs[((8u * v_v) + v_u)])));
v_u += 1u;
}
v_v += 1u;
}
v_result_0 = wuffs_base__utility__sign_extend_rshift_u64(((uint64_t)(v_alphas_sum_32 + 2147483648u)), 32u);
self->private_data.f_buffers[a_which][(a_y_offset + v_y)][(a_x_offset + (4u * v_x))] = WUFFS_HANDSUM__BIAS_AND_CLAMP[(v_result_0 & 1023u)];
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
goto ok;
ok:
goto exit;
exit:
return status;
// -------- func handsum.decoder.decode_coeffs
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__decode_coeffs(
wuffs_handsum__decoder* self) {
uint32_t v_bo = 0;
uint8_t v_nibble = 0;
uint32_t v_i = 0;
v_bo = ((uint32_t)(self->private_impl.f_bit_offset));
v_nibble = ((uint8_t)(((uint8_t)(self->private_data.f_bits[((v_bo >> 3u) & 63u)] >> (v_bo & 4u))) & 15u));
self->private_impl.f_coeffs[0u] = ((uint16_t)(((uint16_t)(((uint16_t)(v_nibble)) - 8u)) * 128u));
v_bo += 4u;
v_i = 1u;
while (v_i < 15u) {
v_nibble = ((uint8_t)(((uint8_t)(self->private_data.f_bits[((v_bo >> 3u) & 63u)] >> (v_bo & 4u))) & 15u));
self->private_impl.f_coeffs[WUFFS_HANDSUM__ZIGZAG[v_i]] = ((uint16_t)(((uint16_t)(((uint16_t)(v_nibble)) - 8u)) * 16u));
v_bo += 4u;
v_i += 1u;
}
self->private_impl.f_bit_offset = ((uint16_t)(v_bo));
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.smooth_luma_block_seams
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__smooth_luma_block_seams(
wuffs_handsum__decoder* self) {
uint32_t v_i = 0;
uint8_t v_p0 = 0;
uint8_t v_p1 = 0;
uint32_t v_y0 = 0;
uint32_t v_y1 = 0;
uint32_t v_x0 = 0;
uint32_t v_x1 = 0;
uint32_t v_v0 = 0;
uint32_t v_v1 = 0;
uint32_t v_w0 = 0;
uint32_t v_w1 = 0;
uint32_t v_v77 = 0;
uint32_t v_v78 = 0;
uint32_t v_v88 = 0;
uint32_t v_v87 = 0;
uint32_t v_w77 = 0;
uint32_t v_w78 = 0;
uint32_t v_w88 = 0;
uint32_t v_w87 = 0;
v_i = 0u;
while (v_i <= 54u) {
v_p0 = WUFFS_HANDSUM__SMOOTHING_PAIRS[(v_i + 0u)];
v_p1 = WUFFS_HANDSUM__SMOOTHING_PAIRS[(v_i + 1u)];
v_y0 = ((uint32_t)(((uint8_t)(v_p0 >> 4u))));
v_y1 = ((uint32_t)(((uint8_t)(v_p1 >> 4u))));
v_x0 = ((uint32_t)(((uint8_t)(v_p0 & 15u))));
v_x1 = ((uint32_t)(((uint8_t)(v_p1 & 15u))));
v_v0 = ((uint32_t)(self->private_data.f_buffers[0u][v_y0][(v_x0 * 4u)]));
v_v1 = ((uint32_t)(self->private_data.f_buffers[0u][v_y1][(v_x1 * 4u)]));
v_w0 = (((3u * v_v0) + v_v1 + 2u) / 4u);
v_w1 = (((3u * v_v1) + v_v0 + 2u) / 4u);
self->private_data.f_buffers[0u][v_y0][(v_x0 * 4u)] = ((uint8_t)(v_w0));
self->private_data.f_buffers[0u][v_y1][(v_x1 * 4u)] = ((uint8_t)(v_w1));
v_i += 2u;
}
v_v77 = ((uint32_t)(self->private_data.f_buffers[0u][7u][28u]));
v_v78 = ((uint32_t)(self->private_data.f_buffers[0u][7u][32u]));
v_v88 = ((uint32_t)(self->private_data.f_buffers[0u][8u][32u]));
v_v87 = ((uint32_t)(self->private_data.f_buffers[0u][8u][28u]));
v_w77 = (((9u * v_v77) +
(3u * v_v78) +
v_v88 +
(3u * v_v87) +
8u) / 16u);
v_w78 = (((9u * v_v78) +
(3u * v_v88) +
v_v87 +
(3u * v_v77) +
8u) / 16u);
v_w88 = (((9u * v_v88) +
(3u * v_v87) +
v_v77 +
(3u * v_v78) +
8u) / 16u);
v_w87 = (((9u * v_v87) +
(3u * v_v77) +
v_v78 +
(3u * v_v88) +
8u) / 16u);
self->private_data.f_buffers[0u][7u][28u] = ((uint8_t)(v_w77));
self->private_data.f_buffers[0u][7u][32u] = ((uint8_t)(v_w78));
self->private_data.f_buffers[0u][8u][32u] = ((uint8_t)(v_w88));
self->private_data.f_buffers[0u][8u][28u] = ((uint8_t)(v_w87));
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.upsample_chroma
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__upsample_chroma(
wuffs_handsum__decoder* self) {
uint32_t v_y = 0;
uint32_t v_dy = 0;
uint32_t v_y0 = 0;
uint32_t v_y1 = 0;
uint32_t v_x = 0;
uint32_t v_dx = 0;
uint32_t v_x0 = 0;
uint32_t v_x1 = 0;
v_y = 0u;
while (v_y < 16u) {
v_dy = ((uint32_t)(((v_y & 1u) * 2u) - 1u));
v_y0 = (v_y >> 1u);
v_y1 = ((uint32_t)(WUFFS_HANDSUM__CLAMP_7[(((uint32_t)(v_y0 + v_dy)) & 31u)]));
v_x = 0u;
while (v_x < 16u) {
v_dx = ((uint32_t)(((v_x & 1u) * 2u) - 1u));
v_x0 = (v_x >> 1u);
v_x1 = ((uint32_t)(WUFFS_HANDSUM__CLAMP_7[(((uint32_t)(v_x0 + v_dx)) & 31u)]));
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 1u)] = ((uint8_t)((((((uint32_t)(self->private_data.f_buffers[1u][v_y0][((4u * v_x0) + 1u)])) * 9u) +
(((uint32_t)(self->private_data.f_buffers[1u][v_y0][((4u * v_x1) + 1u)])) * 3u) +
(((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x0) + 1u)])) * 3u) +
((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x1) + 1u)])) +
8u) / 16u)));
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 2u)] = ((uint8_t)((((((uint32_t)(self->private_data.f_buffers[1u][v_y0][((4u * v_x0) + 2u)])) * 9u) +
(((uint32_t)(self->private_data.f_buffers[1u][v_y0][((4u * v_x1) + 2u)])) * 3u) +
(((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x0) + 2u)])) * 3u) +
((uint32_t)(self->private_data.f_buffers[1u][v_y1][((4u * v_x1) + 2u)])) +
8u) / 16u)));
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.upsample_bgr
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__upsample_bgr(
wuffs_handsum__decoder* self) {
uint32_t v_y = 0;
uint32_t v_dy = 0;
uint32_t v_y0 = 0;
uint32_t v_y1 = 0;
uint32_t v_x = 0;
uint32_t v_dx = 0;
uint32_t v_x0 = 0;
uint32_t v_x1 = 0;
v_y = 0u;
while (v_y < 32u) {
v_dy = ((uint32_t)(((v_y & 1u) * 2u) - 1u));
v_y0 = (v_y >> 1u);
v_y1 = ((uint32_t)(WUFFS_HANDSUM__CLAMP_15[(((uint32_t)(v_y0 + v_dy)) & 63u)]));
v_x = 0u;
while (v_x < 32u) {
v_dx = ((uint32_t)(((v_x & 1u) * 2u) - 1u));
v_x0 = (v_x >> 1u);
v_x1 = ((uint32_t)(WUFFS_HANDSUM__CLAMP_15[(((uint32_t)(v_x0 + v_dx)) & 63u)]));
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 0u)] = ((uint8_t)((((((uint32_t)(self->private_data.f_buffers[0u][v_y0][((4u * v_x0) + 0u)])) * 9u) +
(((uint32_t)(self->private_data.f_buffers[0u][v_y0][((4u * v_x1) + 0u)])) * 3u) +
(((uint32_t)(self->private_data.f_buffers[0u][v_y1][((4u * v_x0) + 0u)])) * 3u) +
((uint32_t)(self->private_data.f_buffers[0u][v_y1][((4u * v_x1) + 0u)])) +
8u) / 16u)));
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] = ((uint8_t)((((((uint32_t)(self->private_data.f_buffers[0u][v_y0][((4u * v_x0) + 1u)])) * 9u) +
(((uint32_t)(self->private_data.f_buffers[0u][v_y0][((4u * v_x1) + 1u)])) * 3u) +
(((uint32_t)(self->private_data.f_buffers[0u][v_y1][((4u * v_x0) + 1u)])) * 3u) +
((uint32_t)(self->private_data.f_buffers[0u][v_y1][((4u * v_x1) + 1u)])) +
8u) / 16u)));
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] = ((uint8_t)((((((uint32_t)(self->private_data.f_buffers[0u][v_y0][((4u * v_x0) + 2u)])) * 9u) +
(((uint32_t)(self->private_data.f_buffers[0u][v_y0][((4u * v_x1) + 2u)])) * 3u) +
(((uint32_t)(self->private_data.f_buffers[0u][v_y1][((4u * v_x0) + 2u)])) * 3u) +
((uint32_t)(self->private_data.f_buffers[0u][v_y1][((4u * v_x1) + 2u)])) +
8u) / 16u)));
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 3u)] = 255u;
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.convert_ycc_to_bgr
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__convert_ycc_to_bgr(
wuffs_handsum__decoder* self) {
uint32_t v_y = 0;
uint32_t v_x = 0;
uint32_t v_yy1 = 0;
uint32_t v_cb1 = 0;
uint32_t v_cr1 = 0;
uint32_t v_r = 0;
uint32_t v_g = 0;
uint32_t v_b = 0;
v_y = 0u;
while (v_y < 16u) {
v_x = 0u;
while (v_x < 16u) {
v_yy1 = (((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_x) + 0u)])) * 65793u);
v_cb1 = ((uint32_t)(((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_x) + 1u)])) - 128u));
v_cr1 = ((uint32_t)(((uint32_t)(self->private_data.f_buffers[0u][v_y][((4u * v_x) + 2u)])) - 128u));
v_r = ((uint32_t)(v_yy1 + ((uint32_t)(91881u * v_cr1))));
if ((v_r & 4278190080u) == 0u) {
v_r >>= 16u;
} else {
v_r = (4294967295u ^ wuffs_base__utility__sign_extend_rshift_u32(v_r, 31u));
}
v_g = ((uint32_t)(v_yy1 - ((uint32_t)(((uint32_t)(22554u * v_cb1)) + ((uint32_t)(46802u * v_cr1))))));
if ((v_g & 4278190080u) == 0u) {
v_g >>= 16u;
} else {
v_g = (4294967295u ^ wuffs_base__utility__sign_extend_rshift_u32(v_g, 31u));
}
v_b = ((uint32_t)(v_yy1 + ((uint32_t)(116130u * v_cb1))));
if ((v_b & 4278190080u) == 0u) {
v_b >>= 16u;
} else {
v_b = (4294967295u ^ wuffs_base__utility__sign_extend_rshift_u32(v_b, 31u));
}
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 0u)] = ((uint8_t)(v_b));
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 1u)] = ((uint8_t)(v_g));
self->private_data.f_buffers[0u][v_y][((4u * v_x) + 2u)] = ((uint8_t)(v_r));
v_x += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.scale_1d_horizontal
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__scale_1d_horizontal(
wuffs_handsum__decoder* self) {
uint32_t v_y = 0;
uint32_t v_dstx = 0;
uint32_t v_srcx = 0;
uint32_t v_acc0 = 0;
uint32_t v_acc1 = 0;
uint32_t v_acc2 = 0;
uint32_t v_s0 = 0;
uint32_t v_s1 = 0;
uint32_t v_s2 = 0;
uint32_t v_remainder = 0;
uint32_t v_partial = 0;
v_y = 0u;
while (v_y < 32u) {
v_dstx = 0u;
v_srcx = 0u;
v_acc0 = 0u;
v_acc1 = 0u;
v_acc2 = 0u;
v_remainder = 32u;
while (v_srcx < 32u) {
v_s0 = ((uint32_t)(self->private_data.f_buffers[1u][v_y][((4u * v_srcx) + 0u)]));
v_s1 = ((uint32_t)(self->private_data.f_buffers[1u][v_y][((4u * v_srcx) + 1u)]));
v_s2 = ((uint32_t)(self->private_data.f_buffers[1u][v_y][((4u * v_srcx) + 2u)]));
if (v_remainder > self->private_impl.f_width) {
v_remainder -= self->private_impl.f_width;
v_acc0 += (self->private_impl.f_width * v_s0);
v_acc1 += (self->private_impl.f_width * v_s1);
v_acc2 += (self->private_impl.f_width * v_s2);
} else {
v_acc0 += (v_remainder * v_s0);
v_acc1 += (v_remainder * v_s1);
v_acc2 += (v_remainder * v_s2);
self->private_data.f_buffers[0u][v_y][((4u * v_dstx) + 0u)] = ((uint8_t)((((uint32_t)(v_acc0 + 16u)) / 32u)));
self->private_data.f_buffers[0u][v_y][((4u * v_dstx) + 1u)] = ((uint8_t)((((uint32_t)(v_acc1 + 16u)) / 32u)));
self->private_data.f_buffers[0u][v_y][((4u * v_dstx) + 2u)] = ((uint8_t)((((uint32_t)(v_acc2 + 16u)) / 32u)));
self->private_data.f_buffers[0u][v_y][((4u * v_dstx) + 3u)] = 255u;
v_dstx = ((v_dstx + 1u) & 31u);
v_partial = (self->private_impl.f_width - v_remainder);
v_acc0 = (v_partial * v_s0);
v_acc1 = (v_partial * v_s1);
v_acc2 = (v_partial * v_s2);
v_remainder = (32u - v_partial);
}
v_srcx += 1u;
}
v_y += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.scale_1d_vertical
WUFFS_BASE__GENERATED_C_CODE
static wuffs_base__empty_struct
wuffs_handsum__decoder__scale_1d_vertical(
wuffs_handsum__decoder* self) {
uint32_t v_x = 0;
uint32_t v_dsty = 0;
uint32_t v_srcy = 0;
uint32_t v_acc0 = 0;
uint32_t v_acc1 = 0;
uint32_t v_acc2 = 0;
uint32_t v_s0 = 0;
uint32_t v_s1 = 0;
uint32_t v_s2 = 0;
uint32_t v_remainder = 0;
uint32_t v_partial = 0;
v_x = 0u;
while (v_x < 32u) {
v_dsty = 0u;
v_srcy = 0u;
v_acc0 = 0u;
v_acc1 = 0u;
v_acc2 = 0u;
v_remainder = 32u;
while (v_srcy < 32u) {
v_s0 = ((uint32_t)(self->private_data.f_buffers[1u][v_srcy][((4u * v_x) + 0u)]));
v_s1 = ((uint32_t)(self->private_data.f_buffers[1u][v_srcy][((4u * v_x) + 1u)]));
v_s2 = ((uint32_t)(self->private_data.f_buffers[1u][v_srcy][((4u * v_x) + 2u)]));
if (v_remainder > self->private_impl.f_height) {
v_remainder -= self->private_impl.f_height;
v_acc0 += (self->private_impl.f_height * v_s0);
v_acc1 += (self->private_impl.f_height * v_s1);
v_acc2 += (self->private_impl.f_height * v_s2);
} else {
v_acc0 += (v_remainder * v_s0);
v_acc1 += (v_remainder * v_s1);
v_acc2 += (v_remainder * v_s2);
self->private_data.f_buffers[0u][v_dsty][((4u * v_x) + 0u)] = ((uint8_t)((((uint32_t)(v_acc0 + 16u)) / 32u)));
self->private_data.f_buffers[0u][v_dsty][((4u * v_x) + 1u)] = ((uint8_t)((((uint32_t)(v_acc1 + 16u)) / 32u)));
self->private_data.f_buffers[0u][v_dsty][((4u * v_x) + 2u)] = ((uint8_t)((((uint32_t)(v_acc2 + 16u)) / 32u)));
self->private_data.f_buffers[0u][v_dsty][((4u * v_x) + 3u)] = 255u;
v_dsty = ((v_dsty + 1u) & 31u);
v_partial = (self->private_impl.f_height - v_remainder);
v_acc0 = (v_partial * v_s0);
v_acc1 = (v_partial * v_s1);
v_acc2 = (v_partial * v_s2);
v_remainder = (32u - v_partial);
}
v_srcy += 1u;
}
v_x += 1u;
}
return wuffs_base__make_empty_struct();
}
// -------- func handsum.decoder.from_pixels_to_dst
+627 -10
View File
@@ -39,9 +39,14 @@ pub struct decoder? implements base.image_decoder(
// (/doc/std/image-decoders-call-sequence.md).
call_sequence : base.u8,
bit_offset : base.u16,
coeffs : array[40] base.u16,
swizzler : base.pixel_swizzler,
util : base.utility,
) + (
bits : array[64] base.u8,
buffers : array[2] array[32] array[128] base.u8,
)
@@ -161,7 +166,9 @@ 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 status : base.status
var num_read : base.u32
var which : base.u32[..= 1]
if this.call_sequence == 0x40 {
// No-op.
@@ -181,8 +188,37 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
return status
}
this.from_src_to_pixels?(src: args.src)
status = this.from_pixels_to_dst!(dst: args.dst, which: 0)
while num_read < 45 {
num_read ~mod+= args.src.limited_copy_u32_to_slice!(
up_to: 45 - num_read,
s: this.bits[num_read ..])
if num_read < 45 {
yield? base."$short read"
}
}
this.bit_offset = 0
this.decode_block!(which: 0, y_offset: 0, x_offset: 4 * 0)
this.decode_block!(which: 0, y_offset: 0, x_offset: 4 * 8)
this.decode_block!(which: 0, y_offset: 8, x_offset: 4 * 0)
this.decode_block!(which: 0, y_offset: 8, x_offset: 4 * 8)
this.decode_block!(which: 1, y_offset: 0, x_offset: 1)
this.decode_block!(which: 1, y_offset: 0, x_offset: 2)
this.smooth_luma_block_seams!()
this.upsample_chroma!()
this.convert_ycc_to_bgr!()
this.upsample_bgr!()
which = 1
if this.width < 32 {
which = 0
this.scale_1d_horizontal!()
} else if this.height < 32 {
which = 0
this.scale_1d_vertical!()
}
status = this.from_pixels_to_dst!(dst: args.dst, which: which)
if not status.is_ok() {
return status
}
@@ -190,29 +226,443 @@ 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_pixels?(src: base.io_reader) {
// decode_block calls decode_coeffs and then performs an Inverse Discrete
// Cosine Transform. The IDCT algorithm is equivalent to the lowleveljpeg Go
// package's BlockU8.InverseDCTFrom code, although Handsum only needs to go up
// to (5, 5) in DCT space, instead of (8, 8).
pri func decoder.decode_block!(which: base.u32[..= 1], y_offset: base.u32[..= 8], x_offset: base.u32[..= 32]) {
var y : base.u32
var x : base.u32
var v : base.u32
var u : base.u32
// TODO: actually implement the format. For now, fill in a placeholder
// blue-green gradient.
var alphas_sum_32 : base.u64
var half_alpha_v_16 : base.u64
var half_alpha_u_16 : base.u64
var alphas_16 : base.u64
var c_32 : base.u64
var c_16 : base.u64
var result_0 : base.u64
this.decode_coeffs!()
y = 0
while y < 8 {
x = 0
while x < 8,
inv y < 8,
{
alphas_sum_32 = 0
v = 0
while v < 5,
inv y < 8,
inv x < 8,
{
half_alpha_v_16 = FIXED_POINT_INV_2_SQRT_2 as base.u64
if v <> 0 {
half_alpha_v_16 = FIXED_POINT_HALF as base.u64
}
u = 0
while u < 5,
inv y < 8,
inv x < 8,
inv v < 5,
{
half_alpha_u_16 = FIXED_POINT_INV_2_SQRT_2 as base.u64
if u <> 0 {
half_alpha_u_16 = FIXED_POINT_HALF as base.u64
}
alphas_16 = this.util.sign_extend_rshift_u64(
a: (half_alpha_v_16 ~mod* half_alpha_u_16) ~mod+ (1 << 15),
n: 16)
c_32 = this.util.sign_extend_convert_u32_u64(a: COSINES[(((2 * x) + 1) * u) & 31]) ~mod*
this.util.sign_extend_convert_u32_u64(a: COSINES[(((2 * y) + 1) * v) & 31])
c_16 = this.util.sign_extend_rshift_u64(
a: c_32 ~mod+ (1 << 15),
n: 16)
alphas_sum_32 ~mod+= (alphas_16 ~mod* c_16) ~mod*
this.util.sign_extend_convert_u16_u64(
a: this.coeffs[(8 * v) + u])
u += 1
}
v += 1
}
result_0 = this.util.sign_extend_rshift_u64(
a: alphas_sum_32 ~mod+ (1 << 31),
n: 32)
this.buffers[args.which][args.y_offset + y][args.x_offset + (4 * x)] =
BIAS_AND_CLAMP[result_0 & 1023]
x += 1
}
y += 1
}
}
pri func decoder.decode_coeffs!() {
var bo : base.u32
var nibble : base.u8[..= 15]
var i : base.u32
bo = this.bit_offset as base.u32
nibble = (this.bits[(bo >> 3) & 63] >> (bo & 4)) & 15
this.coeffs[0] = ((nibble as base.u16) ~mod- 8) ~mod* 128
bo ~mod+= 4
i = 1
while i < 15 {
nibble = (this.bits[(bo >> 3) & 63] >> (bo & 4)) & 15
this.coeffs[ZIGZAG[i]] = ((nibble as base.u16) ~mod- 8) ~mod* 16
bo ~mod+= 4
i += 1
}
this.bit_offset = (bo & 0xFFFF) as base.u16
}
pri func decoder.smooth_luma_block_seams!() {
var i : base.u32
var p0 : base.u8
var p1 : base.u8
var y0 : base.u32[..= 15]
var y1 : base.u32[..= 15]
var x0 : base.u32[..= 15]
var x1 : base.u32[..= 15]
var v0 : base.u32[..= 255]
var v1 : base.u32[..= 255]
var w0 : base.u32[..= 255]
var w1 : base.u32[..= 255]
var v77 : base.u32[..= 255]
var v78 : base.u32[..= 255]
var v88 : base.u32[..= 255]
var v87 : base.u32[..= 255]
var w77 : base.u32[..= 255]
var w78 : base.u32[..= 255]
var w88 : base.u32[..= 255]
var w87 : base.u32[..= 255]
i = 0
while i <= 54 {
p0 = SMOOTHING_PAIRS[i + 0]
p1 = SMOOTHING_PAIRS[i + 1]
y0 = (p0 >> 4) as base.u32
y1 = (p1 >> 4) as base.u32
x0 = (p0 & 15) as base.u32
x1 = (p1 & 15) as base.u32
v0 = this.buffers[0][y0][x0 * 4] as base.u32
v1 = this.buffers[0][y1][x1 * 4] as base.u32
w0 = ((3 * v0) + v1 + 2) / 4
w1 = ((3 * v1) + v0 + 2) / 4
this.buffers[0][y0][x0 * 4] = w0 as base.u8
this.buffers[0][y1][x1 * 4] = w1 as base.u8
i += 2
}
v77 = this.buffers[0][7][7 * 4] as base.u32
v78 = this.buffers[0][7][8 * 4] as base.u32
v88 = this.buffers[0][8][8 * 4] as base.u32
v87 = this.buffers[0][8][7 * 4] as base.u32
w77 = ((9 * v77) + (3 * v78) + v88 + (3 * v87) + 8) / 16
w78 = ((9 * v78) + (3 * v88) + v87 + (3 * v77) + 8) / 16
w88 = ((9 * v88) + (3 * v87) + v77 + (3 * v78) + 8) / 16
w87 = ((9 * v87) + (3 * v77) + v78 + (3 * v88) + 8) / 16
this.buffers[0][7][7 * 4] = w77 as base.u8
this.buffers[0][7][8 * 4] = w78 as base.u8
this.buffers[0][8][8 * 4] = w88 as base.u8
this.buffers[0][8][7 * 4] = w87 as base.u8
}
pri func decoder.upsample_chroma!() {
var y : base.u32
var dy : base.u32
var y0 : base.u32[..= 7]
var y1 : base.u32[..= 7]
var x : base.u32
var dx : base.u32
var x0 : base.u32[..= 7]
var x1 : base.u32[..= 7]
y = 0
while y < 16 {
dy = (((y & 1) * 2) ~mod- 1)
y0 = y >> 1
y1 = CLAMP_7[(y0 ~mod+ dy) & 31] as base.u32
x = 0
while x < 16,
inv y < 16,
{
dx = (((x & 1) * 2) ~mod- 1)
x0 = x >> 1
x1 = CLAMP_7[(x0 ~mod+ dx) & 31] as base.u32
this.buffers[0][y][(4 * x) + 1] = ((
((this.buffers[1][y0][(4 * x0) + 1] as base.u32) * 9) +
((this.buffers[1][y0][(4 * x1) + 1] as base.u32) * 3) +
((this.buffers[1][y1][(4 * x0) + 1] as base.u32) * 3) +
(this.buffers[1][y1][(4 * x1) + 1] as base.u32) + 8) / 16) as base.u8
this.buffers[0][y][(4 * x) + 2] = ((
((this.buffers[1][y0][(4 * x0) + 2] as base.u32) * 9) +
((this.buffers[1][y0][(4 * x1) + 2] as base.u32) * 3) +
((this.buffers[1][y1][(4 * x0) + 2] as base.u32) * 3) +
(this.buffers[1][y1][(4 * x1) + 2] as base.u32) + 8) / 16) as base.u8
x += 1
}
y += 1
}
}
pri func decoder.upsample_bgr!() {
var y : base.u32
var dy : base.u32
var y0 : base.u32[..= 15]
var y1 : base.u32[..= 15]
var x : base.u32
var dx : base.u32
var x0 : base.u32[..= 15]
var x1 : base.u32[..= 15]
y = 0
while y < 32 {
dy = (((y & 1) * 2) ~mod- 1)
y0 = y >> 1
y1 = CLAMP_15[(y0 ~mod+ dy) & 63] as base.u32
x = 0
while x < 32,
inv y < 32,
{
this.buffers[0][y][(4 * x) + 0] = (x * 8) as base.u8
this.buffers[0][y][(4 * x) + 1] = (y * 8) as base.u8
this.buffers[0][y][(4 * x) + 2] = 0x00
this.buffers[0][y][(4 * x) + 3] = 0xFF
dx = (((x & 1) * 2) ~mod- 1)
x0 = x >> 1
x1 = CLAMP_15[(x0 ~mod+ dx) & 63] as base.u32
this.buffers[1][y][(4 * x) + 0] = ((
((this.buffers[0][y0][(4 * x0) + 0] as base.u32) * 9) +
((this.buffers[0][y0][(4 * x1) + 0] as base.u32) * 3) +
((this.buffers[0][y1][(4 * x0) + 0] as base.u32) * 3) +
(this.buffers[0][y1][(4 * x1) + 0] as base.u32) + 8) / 16) as base.u8
this.buffers[1][y][(4 * x) + 1] = ((
((this.buffers[0][y0][(4 * x0) + 1] as base.u32) * 9) +
((this.buffers[0][y0][(4 * x1) + 1] as base.u32) * 3) +
((this.buffers[0][y1][(4 * x0) + 1] as base.u32) * 3) +
(this.buffers[0][y1][(4 * x1) + 1] as base.u32) + 8) / 16) as base.u8
this.buffers[1][y][(4 * x) + 2] = ((
((this.buffers[0][y0][(4 * x0) + 2] as base.u32) * 9) +
((this.buffers[0][y0][(4 * x1) + 2] as base.u32) * 3) +
((this.buffers[0][y1][(4 * x0) + 2] as base.u32) * 3) +
(this.buffers[0][y1][(4 * x1) + 2] as base.u32) + 8) / 16) as base.u8
this.buffers[1][y][(4 * x) + 3] = 0xFF
x += 1
}
y += 1
}
}
pri func decoder.convert_ycc_to_bgr!() {
var y : base.u32
var x : base.u32
var yy1 : base.u32
var cb1 : base.u32
var cr1 : base.u32
var r : base.u32
var g : base.u32
var b : base.u32
y = 0
while y < 16 {
x = 0
while x < 16,
inv y < 16,
{
// This conversion algorithm is the same as the one used by
// src/image/color/ycbcr.go in Go's standard library.
yy1 = (this.buffers[0][y][(4 * x) + 0] as base.u32) * 0x1_0101
cb1 = (this.buffers[0][y][(4 * x) + 1] as base.u32) ~mod- 0x80
cr1 = (this.buffers[0][y][(4 * x) + 2] as base.u32) ~mod- 0x80
r = yy1 ~mod+ (91881 ~mod* cr1)
if (r & 0xFF00_0000) == 0 {
r >>= 16
} else {
r = 0xFFFF_FFFF ^ this.util.sign_extend_rshift_u32(a: r, n: 31)
}
g = yy1 ~mod- ((22554 ~mod* cb1) ~mod+ (46802 ~mod* cr1))
if (g & 0xFF00_0000) == 0 {
g >>= 16
} else {
g = 0xFFFF_FFFF ^ this.util.sign_extend_rshift_u32(a: g, n: 31)
}
b = yy1 ~mod+ (116130 ~mod* cb1)
if (b & 0xFF00_0000) == 0 {
b >>= 16
} else {
b = 0xFFFF_FFFF ^ this.util.sign_extend_rshift_u32(a: b, n: 31)
}
this.buffers[0][y][(4 * x) + 0] = (b & 0xFF) as base.u8
this.buffers[0][y][(4 * x) + 1] = (g & 0xFF) as base.u8
this.buffers[0][y][(4 * x) + 2] = (r & 0xFF) as base.u8
x += 1
}
y += 1
}
}
pri func decoder.scale_1d_horizontal!() {
var y : base.u32
var dstx : base.u32[..= 31]
var srcx : base.u32
var acc0 : base.u32
var acc1 : base.u32
var acc2 : base.u32
var s0 : base.u32[..= 0xFF]
var s1 : base.u32[..= 0xFF]
var s2 : base.u32[..= 0xFF]
var remainder : base.u32[..= 32]
var partial : base.u32[..= 32]
y = 0
while y < 32 {
dstx = 0
srcx = 0
acc0 = 0
acc1 = 0
acc2 = 0
remainder = 32
while srcx < 32,
inv y < 32,
{
s0 = this.buffers[1][y][(4 * srcx) + 0] as base.u32
s1 = this.buffers[1][y][(4 * srcx) + 1] as base.u32
s2 = this.buffers[1][y][(4 * srcx) + 2] as base.u32
if remainder > this.width {
remainder -= this.width
acc0 ~mod+= this.width * s0
acc1 ~mod+= this.width * s1
acc2 ~mod+= this.width * s2
} else {
assert this.width >= remainder via "a >= b: b <= a"()
acc0 ~mod+= remainder * s0
acc1 ~mod+= remainder * s1
acc2 ~mod+= remainder * s2
this.buffers[0][y][(4 * dstx) + 0] = (((acc0 ~mod+ 16) / 32) & 0xFF) as base.u8
this.buffers[0][y][(4 * dstx) + 1] = (((acc1 ~mod+ 16) / 32) & 0xFF) as base.u8
this.buffers[0][y][(4 * dstx) + 2] = (((acc2 ~mod+ 16) / 32) & 0xFF) as base.u8
this.buffers[0][y][(4 * dstx) + 3] = 0xFF
dstx = (dstx + 1) & 31
partial = this.width - remainder
acc0 = partial * s0
acc1 = partial * s1
acc2 = partial * s2
remainder = 32 - partial
}
srcx += 1
}
y += 1
}
}
pri func decoder.scale_1d_vertical!() {
var x : base.u32
var dsty : base.u32[..= 31]
var srcy : base.u32
var acc0 : base.u32
var acc1 : base.u32
var acc2 : base.u32
var s0 : base.u32[..= 0xFF]
var s1 : base.u32[..= 0xFF]
var s2 : base.u32[..= 0xFF]
var remainder : base.u32[..= 32]
var partial : base.u32[..= 32]
x = 0
while x < 32 {
dsty = 0
srcy = 0
acc0 = 0
acc1 = 0
acc2 = 0
remainder = 32
while srcy < 32,
inv x < 32,
{
s0 = this.buffers[1][srcy][(4 * x) + 0] as base.u32
s1 = this.buffers[1][srcy][(4 * x) + 1] as base.u32
s2 = this.buffers[1][srcy][(4 * x) + 2] as base.u32
if remainder > this.height {
remainder -= this.height
acc0 ~mod+= this.height * s0
acc1 ~mod+= this.height * s1
acc2 ~mod+= this.height * s2
} else {
assert this.height >= remainder via "a >= b: b <= a"()
acc0 ~mod+= remainder * s0
acc1 ~mod+= remainder * s1
acc2 ~mod+= remainder * s2
this.buffers[0][dsty][(4 * x) + 0] = (((acc0 ~mod+ 16) / 32) & 0xFF) as base.u8
this.buffers[0][dsty][(4 * x) + 1] = (((acc1 ~mod+ 16) / 32) & 0xFF) as base.u8
this.buffers[0][dsty][(4 * x) + 2] = (((acc2 ~mod+ 16) / 32) & 0xFF) as base.u8
this.buffers[0][dsty][(4 * x) + 3] = 0xFF
dsty = (dsty + 1) & 31
partial = this.height - remainder
acc0 = partial * s0
acc1 = partial * s1
acc2 = partial * s2
remainder = 32 - partial
}
srcy += 1
}
x += 1
}
}
pri func decoder.from_pixels_to_dst!(dst: ptr base.pixel_buffer, which: base.u32[..= 1]) base.status {
var dst_pixfmt : base.pixel_format
var dst_bits_per_pixel : base.u32[..= 256]
@@ -302,3 +752,170 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
pub func decoder.workbuf_len() base.range_ii_u64 {
return this.util.make_range_ii_u64(min_incl: 0, max_incl: 0)
}
pri const CLAMP_7 : roarray[32] base.u8[..= 7] = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]
pri const CLAMP_15 : roarray[64] base.u8[..= 15] = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]
// For commentary on these constants below, see the lib/handsum and
// lib/lowleveljpeg Go packages.
pri const ZIGZAG : roarray[15] base.u8[..= 39] = [
0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4,
]
pri const SMOOTHING_PAIRS : roarray[56] base.u8 = [
0x07, 0x08,
0x17, 0x18,
0x27, 0x28,
0x37, 0x38,
0x47, 0x48,
0x57, 0x58,
0x67, 0x68,
0x70, 0x80,
0x71, 0x81,
0x72, 0x82,
0x73, 0x83,
0x74, 0x84,
0x75, 0x85,
0x76, 0x86,
0x79, 0x89,
0x7A, 0x8A,
0x7B, 0x8B,
0x7C, 0x8C,
0x7D, 0x8D,
0x7E, 0x8E,
0x7F, 0x8F,
0x97, 0x98,
0xA7, 0xA8,
0xB7, 0xB8,
0xC7, 0xC8,
0xD7, 0xD8,
0xE7, 0xE8,
0xF7, 0xF8,
]
pri const FIXED_POINT_HALF : base.u16 = 0x8000
pri const FIXED_POINT_INV_2_SQRT_2 : base.u16 = 0x5A82
pri const COSINES : roarray[32] base.u32 = [
0x0001_0000,
0x0000_FB14,
0x0000_EC83,
0x0000_D4DB,
0x0000_B504,
0x0000_8E39,
0x0000_61F7,
0x0000_31F1,
0x0000_0000,
0xFFFF_CE0F,
0xFFFF_9E09,
0xFFFF_71C7,
0xFFFF_4AFC,
0xFFFF_2B25,
0xFFFF_137D,
0xFFFF_04EC,
0xFFFF_0000,
0xFFFF_04EC,
0xFFFF_137D,
0xFFFF_2B25,
0xFFFF_4AFC,
0xFFFF_71C7,
0xFFFF_9E09,
0xFFFF_CE0F,
0x0000_0000,
0x0000_31F1,
0x0000_61F7,
0x0000_8E39,
0x0000_B504,
0x0000_D4DB,
0x0000_EC83,
0x0000_FB14,
]
pri const BIAS_AND_CLAMP : roarray[1024] base.u8 = [
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
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,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
]
+1 -1
View File
@@ -75,7 +75,7 @@ test_wuffs_handsum_decode_interface() {
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
return do_test__wuffs_base__image_decoder(
wuffs_handsum__decoder__upcast_as__wuffs_base__image_decoder(&dec),
"test/data/bricks-color.handsum", 0, SIZE_MAX, 32, 24, 0xFF00B8F8);
"test/data/bricks-color.handsum", 0, SIZE_MAX, 32, 24, 0xFF571218);
}
const char* //
+2 -2
View File
@@ -48,7 +48,7 @@ OK. 076cb375 test/data/bricks-color.bmp
OK. bdbbfadb test/data/bricks-color.etc1.pkm
OK. 41e6110e test/data/bricks-color.etc1s.pkm
OK. 5670f263 test/data/bricks-color.etc2.pkm
OK. 16e19d11 test/data/bricks-color.handsum
OK. 1fef6814 test/data/bricks-color.handsum
OK. 72a1f9cc test/data/bricks-color.jpeg
OK. 076cb375 test/data/bricks-color.lossless.webp
OK. 9d451b1c test/data/bricks-color.lossy.webp
@@ -122,7 +122,7 @@ OK. ed4b78fc test/data/hippopotamus.regular.gif
OK. dcbb225a test/data/hippopotamus.regular.png
BAD e4c5926b test/data/hippopotamus.regular.truncated.png
OK. f6bb81e2 test/data/mona-lisa.21x32.etc2.pkm
OK. e93a8448 test/data/mona-lisa.21x32.handsum
OK. b507f884 test/data/mona-lisa.21x32.handsum
OK. 012ce4cf test/data/mona-lisa.21x32.png
OK. 0a22e689 test/data/mona-lisa.21x32.q50.jpeg
OK. 059ecb80 test/data/mona-lisa.21x32.q90.jpeg