diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 58acad96..450ab0c2 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -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 diff --git a/std/handsum/decode_handsum.wuffs b/std/handsum/decode_handsum.wuffs index 10c17285..ba735985 100644 --- a/std/handsum/decode_handsum.wuffs +++ b/std/handsum/decode_handsum.wuffs @@ -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, +] diff --git a/test/c/std/handsum.c b/test/c/std/handsum.c index f1551788..5759dbfe 100644 --- a/test/c/std/handsum.c +++ b/test/c/std/handsum.c @@ -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* // diff --git a/test/nia-checksums-of-data.txt b/test/nia-checksums-of-data.txt index 8976f7e8..196d36b4 100644 --- a/test/nia-checksums-of-data.txt +++ b/test/nia-checksums-of-data.txt @@ -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