diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 1397c91e..c819c72d 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -9118,6 +9118,7 @@ struct wuffs_etc2__decoder__struct { uint32_t f_height; uint32_t f_remaining_blocks; uint8_t f_call_sequence; + bool f_srgb; uint32_t f_buffer_index; uint32_t f_dst_x; uint32_t f_dst_y; @@ -41021,6 +41022,11 @@ WUFFS_ETC2__MODIFIERS[8][4] WUFFS_BASE__POTENTIALLY_UNUSED = { }, }; +static const uint8_t +WUFFS_ETC2__T_H_MODIFIERS[8] WUFFS_BASE__POTENTIALLY_UNUSED = { + 3u, 6u, 11u, 16u, 23u, 32u, 41u, 64u, +}; + static const uint8_t WUFFS_ETC2__CLAMP[1024] WUFFS_BASE__POTENTIALLY_UNUSED = { 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, @@ -41187,6 +41193,27 @@ wuffs_etc2__decoder__from_src_to_buffer( wuffs_etc2__decoder* self, wuffs_base__io_buffer* a_src); +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_t_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_h_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_planar_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__empty_struct wuffs_etc2__decoder__decode_half_block( @@ -41519,7 +41546,7 @@ wuffs_etc2__decoder__do_decode_image_config( } v_c32 = t_1; } - if (v_c32 == 12337u) { + if ((v_c32 == 12337u) || (v_c32 == 16789554u) || (v_c32 == 151007282u)) { self->private_impl.f_pixfmt = 2415954056u; } else if ((v_c32 & 65535u) == 12338u) { status = wuffs_base__make_status(wuffs_etc2__error__unsupported_etc2_file); @@ -41528,6 +41555,7 @@ wuffs_etc2__decoder__do_decode_image_config( status = wuffs_base__make_status(wuffs_etc2__error__bad_header); goto exit; } + self->private_impl.f_srgb = ((v_c32 >> 24u) >= 9u); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); uint16_t t_2; @@ -42088,15 +42116,30 @@ wuffs_etc2__decoder__from_src_to_buffer( v_b1 = ((v_b1 << 4u) | v_b1); } else { v_r0 = ((uint32_t)((31u & (v_c64 >> 59u)))); - v_r1 = (31u & ((uint32_t)(v_r0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 56u))]))); + v_r1 = ((uint32_t)(v_r0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 56u))])); + if ((v_r1 >> 5u) != 0u) { + wuffs_etc2__decoder__decode_t_mode(self, v_c64, (16u * v_bi)); + v_bi += 1u; + continue; + } v_r0 = (((uint32_t)(v_r0 << 3u)) | (v_r0 >> 2u)); v_r1 = (((uint32_t)(v_r1 << 3u)) | (v_r1 >> 2u)); v_g0 = ((uint32_t)((31u & (v_c64 >> 51u)))); - v_g1 = (31u & ((uint32_t)(v_g0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 48u))]))); + v_g1 = ((uint32_t)(v_g0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 48u))])); + if ((v_g1 >> 5u) != 0u) { + wuffs_etc2__decoder__decode_h_mode(self, v_c64, (16u * v_bi)); + v_bi += 1u; + continue; + } v_g0 = (((uint32_t)(v_g0 << 3u)) | (v_g0 >> 2u)); v_g1 = (((uint32_t)(v_g1 << 3u)) | (v_g1 >> 2u)); v_b0 = ((uint32_t)((31u & (v_c64 >> 43u)))); - v_b1 = (31u & ((uint32_t)(v_b0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 40u))]))); + v_b1 = ((uint32_t)(v_b0 + WUFFS_ETC2__DIFFS[(7u & (v_c64 >> 40u))])); + if ((v_b1 >> 5u) != 0u) { + wuffs_etc2__decoder__decode_planar_mode(self, v_c64, (16u * v_bi)); + v_bi += 1u; + continue; + } v_b0 = (((uint32_t)(v_b0 << 3u)) | (v_b0 >> 2u)); v_b1 = (((uint32_t)(v_b1 << 3u)) | (v_b1 >> 2u)); } @@ -42144,6 +42187,197 @@ wuffs_etc2__decoder__from_src_to_buffer( return status; } +// -------- func etc2.decoder.decode_t_mode + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_t_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset) { + uint8_t v_r[4] = {0}; + uint8_t v_g[4] = {0}; + uint8_t v_b[4] = {0}; + uint32_t v_which = 0; + uint32_t v_delta = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_x4y = 0; + uint32_t v_i = 0; + uint32_t v_o = 0; + + v_r[0u] = ((uint8_t)(((uint8_t)((12u & (a_bits >> 57u)))) | ((uint8_t)((3u & (a_bits >> 56u)))))); + v_r[0u] = ((uint8_t)(((uint8_t)(v_r[0u] << 4u)) | v_r[0u])); + v_g[0u] = ((uint8_t)((15u & (a_bits >> 52u)))); + v_g[0u] = ((uint8_t)(((uint8_t)(v_g[0u] << 4u)) | v_g[0u])); + v_b[0u] = ((uint8_t)((15u & (a_bits >> 48u)))); + v_b[0u] = ((uint8_t)(((uint8_t)(v_b[0u] << 4u)) | v_b[0u])); + v_r[2u] = ((uint8_t)((15u & (a_bits >> 44u)))); + v_r[2u] = ((uint8_t)(((uint8_t)(v_r[2u] << 4u)) | v_r[2u])); + v_g[2u] = ((uint8_t)((15u & (a_bits >> 40u)))); + v_g[2u] = ((uint8_t)(((uint8_t)(v_g[2u] << 4u)) | v_g[2u])); + v_b[2u] = ((uint8_t)((15u & (a_bits >> 36u)))); + v_b[2u] = ((uint8_t)(((uint8_t)(v_b[2u] << 4u)) | v_b[2u])); + v_which = (((uint32_t)((6u & (a_bits >> 33u)))) | ((uint32_t)((1u & (a_bits >> 32u))))); + v_delta = ((uint32_t)(WUFFS_ETC2__T_H_MODIFIERS[v_which])); + v_r[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) + v_delta)) & 1023u)]; + v_g[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) + v_delta)) & 1023u)]; + v_b[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) + v_delta)) & 1023u)]; + v_r[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) - v_delta)) & 1023u)]; + v_g[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) - v_delta)) & 1023u)]; + v_b[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) - v_delta)) & 1023u)]; + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_x4y = ((v_x * 4u) | v_y); + v_i = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + self->private_data.f_buffer[(v_o + 0u)] = v_b[v_i]; + self->private_data.f_buffer[(v_o + 1u)] = v_g[v_i]; + self->private_data.f_buffer[(v_o + 2u)] = v_r[v_i]; + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.decode_h_mode + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_h_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset) { + uint8_t v_r[4] = {0}; + uint8_t v_g[4] = {0}; + uint8_t v_b[4] = {0}; + uint32_t v_rgb0 = 0; + uint32_t v_rgb2 = 0; + uint32_t v_which = 0; + uint32_t v_delta = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_x4y = 0; + uint32_t v_i = 0; + uint32_t v_o = 0; + + v_r[0u] = ((uint8_t)((15u & (a_bits >> 59u)))); + v_r[0u] = ((uint8_t)(((uint8_t)(v_r[0u] << 4u)) | v_r[0u])); + v_g[0u] = ((uint8_t)(((uint8_t)((14u & (a_bits >> 55u)))) | ((uint8_t)((1u & (a_bits >> 52u)))))); + v_g[0u] = ((uint8_t)(((uint8_t)(v_g[0u] << 4u)) | v_g[0u])); + v_b[0u] = ((uint8_t)(((uint8_t)((8u & (a_bits >> 48u)))) | ((uint8_t)((7u & (a_bits >> 47u)))))); + v_b[0u] = ((uint8_t)(((uint8_t)(v_b[0u] << 4u)) | v_b[0u])); + v_r[2u] = ((uint8_t)((15u & (a_bits >> 43u)))); + v_r[2u] = ((uint8_t)(((uint8_t)(v_r[2u] << 4u)) | v_r[2u])); + v_g[2u] = ((uint8_t)((15u & (a_bits >> 39u)))); + v_g[2u] = ((uint8_t)(((uint8_t)(v_g[2u] << 4u)) | v_g[2u])); + v_b[2u] = ((uint8_t)((15u & (a_bits >> 35u)))); + v_b[2u] = ((uint8_t)(((uint8_t)(v_b[2u] << 4u)) | v_b[2u])); + v_rgb0 = ((((uint32_t)(v_r[0u])) << 16u) | (((uint32_t)(v_g[0u])) << 8u) | (((uint32_t)(v_b[0u])) << 0u)); + v_rgb2 = ((((uint32_t)(v_r[2u])) << 16u) | (((uint32_t)(v_g[2u])) << 8u) | (((uint32_t)(v_b[2u])) << 0u)); + v_which = (((uint32_t)((4u & (a_bits >> 32u)))) | ((uint32_t)((2u & (a_bits >> 31u))))); + if (v_rgb0 >= v_rgb2) { + v_which |= 1u; + } + v_delta = ((uint32_t)(WUFFS_ETC2__T_H_MODIFIERS[v_which])); + v_r[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[0u])) - v_delta)) & 1023u)]; + v_g[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[0u])) - v_delta)) & 1023u)]; + v_b[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[0u])) - v_delta)) & 1023u)]; + v_r[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[0u])) + v_delta)) & 1023u)]; + v_g[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[0u])) + v_delta)) & 1023u)]; + v_b[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[0u])) + v_delta)) & 1023u)]; + v_r[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) - v_delta)) & 1023u)]; + v_g[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) - v_delta)) & 1023u)]; + v_b[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) - v_delta)) & 1023u)]; + v_r[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) + v_delta)) & 1023u)]; + v_g[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) + v_delta)) & 1023u)]; + v_b[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) + v_delta)) & 1023u)]; + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_x4y = ((v_x * 4u) | v_y); + v_i = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + self->private_data.f_buffer[(v_o + 0u)] = v_b[v_i]; + self->private_data.f_buffer[(v_o + 1u)] = v_g[v_i]; + self->private_data.f_buffer[(v_o + 2u)] = v_r[v_i]; + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.decode_planar_mode + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_planar_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset) { + uint32_t v_ro = 0; + uint32_t v_go = 0; + uint32_t v_bo = 0; + uint32_t v_rh = 0; + uint32_t v_gh = 0; + uint32_t v_bh = 0; + uint32_t v_rv = 0; + uint32_t v_gv = 0; + uint32_t v_bv = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_o = 0; + uint32_t v_rp = 0; + uint32_t v_gp = 0; + uint32_t v_bp = 0; + + v_ro = ((uint32_t)((63u & (a_bits >> 57u)))); + v_ro = (((uint32_t)(v_ro << 2u)) | (v_ro >> 4u)); + v_go = (((uint32_t)((64u & (a_bits >> 50u)))) | ((uint32_t)((63u & (a_bits >> 49u))))); + v_go = (((uint32_t)(v_go << 1u)) | (v_go >> 6u)); + v_bo = (((uint32_t)((32u & (a_bits >> 43u)))) | ((uint32_t)((24u & (a_bits >> 40u)))) | ((uint32_t)((7u & (a_bits >> 39u))))); + v_bo = (((uint32_t)(v_bo << 2u)) | (v_bo >> 4u)); + v_rh = (((uint32_t)((62u & (a_bits >> 33u)))) | ((uint32_t)((1u & (a_bits >> 32u))))); + v_rh = (((uint32_t)(v_rh << 2u)) | (v_rh >> 4u)); + v_gh = ((uint32_t)((127u & (a_bits >> 25u)))); + v_gh = (((uint32_t)(v_gh << 1u)) | (v_gh >> 6u)); + v_bh = ((uint32_t)((63u & (a_bits >> 19u)))); + v_bh = (((uint32_t)(v_bh << 2u)) | (v_bh >> 4u)); + v_rv = ((uint32_t)((63u & (a_bits >> 13u)))); + v_rv = (((uint32_t)(v_rv << 2u)) | (v_rv >> 4u)); + v_gv = ((uint32_t)((127u & (a_bits >> 6u)))); + v_gv = (((uint32_t)(v_gv << 1u)) | (v_gv >> 6u)); + v_bv = ((uint32_t)((63u & (a_bits >> 0u)))); + v_bv = (((uint32_t)(v_bv << 2u)) | (v_bv >> 4u)); + v_rh -= v_ro; + v_gh -= v_go; + v_bh -= v_bo; + v_rv -= v_ro; + v_gv -= v_go; + v_bv -= v_bo; + v_ro *= 4u; + v_go *= 4u; + v_bo *= 4u; + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + v_bp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_bh)) + ((uint32_t)(v_y * v_bv)))) + v_bo)); + self->private_data.f_buffer[(v_o + 0u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_bp + 2u)) / 4u) & 1023u)]; + v_gp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_gh)) + ((uint32_t)(v_y * v_gv)))) + v_go)); + self->private_data.f_buffer[(v_o + 1u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_gp + 2u)) / 4u) & 1023u)]; + v_rp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_rh)) + ((uint32_t)(v_y * v_rv)))) + v_ro)); + self->private_data.f_buffer[(v_o + 2u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_rp + 2u)) / 4u) & 1023u)]; + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + // -------- func etc2.decoder.decode_half_block WUFFS_BASE__GENERATED_C_CODE diff --git a/std/etc2/decode_etc2.wuffs b/std/etc2/decode_etc2.wuffs index 89b088c4..b8cbbb1e 100644 --- a/std/etc2/decode_etc2.wuffs +++ b/std/etc2/decode_etc2.wuffs @@ -47,6 +47,8 @@ pub struct decoder? implements base.image_decoder( // (/doc/std/image-decoders-call-sequence.md). call_sequence : base.u8, + srgb : base.bool, + // buffer_index is measured in blocks. buffer_index : base.u32[..= 64], @@ -95,13 +97,16 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base. } c32 = args.src.read_u32le?() - if c32 == '10\x00\x00'le { + if (c32 == '10\x00\x00'le) or // ETC1. + (c32 == '20\x00\x01'le) or // ETC2 RGB. + (c32 == '20\x00\x09'le) { // ETC2 sRGB. this.pixfmt = base.PIXEL_FORMAT__BGRX } else if (c32 & 0xFFFF) == '20'le { return "#unsupported ETC2 file" } else { return "#bad header" } + this.srgb = (c32 >> 24) >= 0x09 rounded_up_width = args.src.read_u16be?() rounded_up_height = args.src.read_u16be?() @@ -248,6 +253,12 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) { c64 = args.src.read_u64be?() if (c64 & 0x2_0000_0000) == 0 { + // The high 32 bits of c64: + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec + // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex + // R0 r0 r0 r0 R1 r1 r1 r1 G0 g0 g0 g0 G1 g1 g1 g1 B0 b0 b0 b0 B1 b1 b1 b1 W0 w0 w0 W1 w1 w1 00 Fl + r0 = (0x0F & (c64 >> 0x3C)) as base.u32 r0 = (r0 << 4) | r0 r1 = (0x0F & (c64 >> 0x38)) as base.u32 @@ -264,18 +275,45 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) { b1 = (b1 << 4) | b1 } else { + // The high 32 bits of c64 (unless ETC2's T / H / Planar modes): + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec + // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex + // R0 r0 r0 r0 r0 R1 r1 r1 G0 g0 g0 g0 g0 G1 g1 g1 B0 b0 b0 b0 b0 B1 b1 b1 W0 w0 w0 W1 w1 w1 01 Fl + r0 = (0x1F & (c64 >> 0x3B)) as base.u32 - r1 = (0x1F & (r0 ~mod+ DIFFS[0x07 & (c64 >> 0x38)])) + r1 = r0 ~mod+ DIFFS[0x07 & (c64 >> 0x38)] + if (r1 >> 5) <> 0 { + this.decode_t_mode!( + bits: c64, + offset: 16 * bi) + bi += 1 + continue + } r0 = (r0 ~mod<< 3) | (r0 >> 2) r1 = (r1 ~mod<< 3) | (r1 >> 2) g0 = (0x1F & (c64 >> 0x33)) as base.u32 - g1 = (0x1F & (g0 ~mod+ DIFFS[0x07 & (c64 >> 0x30)])) + g1 = g0 ~mod+ DIFFS[0x07 & (c64 >> 0x30)] + if (g1 >> 5) <> 0 { + this.decode_h_mode!( + bits: c64, + offset: 16 * bi) + bi += 1 + continue + } g0 = (g0 ~mod<< 3) | (g0 >> 2) g1 = (g1 ~mod<< 3) | (g1 >> 2) b0 = (0x1F & (c64 >> 0x2B)) as base.u32 - b1 = (0x1F & (b0 ~mod+ DIFFS[0x07 & (c64 >> 0x28)])) + b1 = b0 ~mod+ DIFFS[0x07 & (c64 >> 0x28)] + if (b1 >> 5) <> 0 { + this.decode_planar_mode!( + bits: c64, + offset: 16 * bi) + bi += 1 + continue + } b0 = (b0 ~mod<< 3) | (b0 >> 2) b1 = (b1 ~mod<< 3) | (b1 >> 2) } @@ -306,6 +344,264 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) { this.buffer_index = bi } +pri func decoder.decode_t_mode!( + bits: base.u64, + offset: base.u32[..= 1008]) { + var r : array[4] base.u8 + var g : array[4] base.u8 + var b : array[4] base.u8 + + var which : base.u32[..= 7] + var delta : base.u32 + + var y : base.u32 + var x : base.u32 + var x4y : base.u32[..= 15] + var i : base.u32[..= 3] + var o : base.u32[..= 4092] + + // Unjumble T-mode's 59 bits and convert from RGB444 to RGB888. + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec + // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex + // .. .. .. R0 r0 .. r0 r0 G0 g0 g0 g0 B0 b0 b0 b0 R2 r2 r2 r2 G2 g2 g2 g2 B2 b2 b2 b2 Wh wh .. wh + // + // The low 32 bits hold "2 bits per pixel" indexes into the r, g, b arrays. + + r[0] = ((0x0C & (args.bits >> 0x39)) as base.u8) | + ((0x03 & (args.bits >> 0x38)) as base.u8) + r[0] = (r[0] << 4) | r[0] + g[0] = (0x0F & (args.bits >> 0x34)) as base.u8 + g[0] = (g[0] << 4) | g[0] + b[0] = (0x0F & (args.bits >> 0x30)) as base.u8 + b[0] = (b[0] << 4) | b[0] + + r[2] = (0x0F & (args.bits >> 0x2C)) as base.u8 + r[2] = (r[2] << 4) | r[2] + g[2] = (0x0F & (args.bits >> 0x28)) as base.u8 + g[2] = (g[2] << 4) | g[2] + b[2] = (0x0F & (args.bits >> 0x24)) as base.u8 + b[2] = (b[2] << 4) | b[2] + + // Modulate. + + which = ((0x06 & (args.bits >> 0x21)) as base.u32) | + ((0x01 & (args.bits >> 0x20)) as base.u32) + delta = T_H_MODIFIERS[which] as base.u32 + + r[1] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023] + g[1] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023] + b[1] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023] + + r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023] + g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023] + b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023] + + // Paint the 4×4 block. + + while y < 4 { + x = 0 + while x < 4, + inv y < 4, + { + x4y = (x * 4) | y + i = (((args.bits >> x4y) & 1) as base.u32) | + (((args.bits >> (x4y + 15)) & 2) as base.u32) + o = args.offset + (x * 4) + (y * 1024) + this.buffer[o + 0] = b[i] + this.buffer[o + 1] = g[i] + this.buffer[o + 2] = r[i] + x += 1 + } + y += 1 + } +} + +pri func decoder.decode_h_mode!( + bits: base.u64, + offset: base.u32[..= 1008]) { + var r : array[4] base.u8 + var g : array[4] base.u8 + var b : array[4] base.u8 + + var rgb0 : base.u32 + var rgb2 : base.u32 + var which : base.u32[..= 7] + var delta : base.u32 + + var y : base.u32 + var x : base.u32 + var x4y : base.u32[..= 15] + var i : base.u32[..= 3] + var o : base.u32[..= 4092] + + // Unjumble H-mode's 58 bits (one of the 'which' bits is implied by order) + // and convert from RGB444 to RGB888. + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec + // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex + // .. R0 r0 r0 r0 G0 g0 g0 .. .. .. g0 B0 .. b0 b0 b0 R2 r2 r2 r2 G2 g2 g2 g2 B2 b2 b2 b2 Wh .. wh + // + // The low 32 bits hold "2 bits per pixel" indexes into the r, g, b arrays. + + r[0] = (0x0F & (args.bits >> 0x3B)) as base.u8 + r[0] = (r[0] << 4) | r[0] + g[0] = ((0x0E & (args.bits >> 0x37)) as base.u8) | + ((0x01 & (args.bits >> 0x34)) as base.u8) + g[0] = (g[0] << 4) | g[0] + b[0] = ((0x08 & (args.bits >> 0x30)) as base.u8) | + ((0x07 & (args.bits >> 0x2F)) as base.u8) + b[0] = (b[0] << 4) | b[0] + + r[2] = (0x0F & (args.bits >> 0x2B)) as base.u8 + r[2] = (r[2] << 4) | r[2] + g[2] = (0x0F & (args.bits >> 0x27)) as base.u8 + g[2] = (g[2] << 4) | g[2] + b[2] = (0x0F & (args.bits >> 0x23)) as base.u8 + b[2] = (b[2] << 4) | b[2] + + // Modulate. + + rgb0 = ((r[0] as base.u32) << 0x10) | + ((g[0] as base.u32) << 0x08) | + ((b[0] as base.u32) << 0x00) + rgb2 = ((r[2] as base.u32) << 0x10) | + ((g[2] as base.u32) << 0x08) | + ((b[2] as base.u32) << 0x00) + which = ((0x04 & (args.bits >> 0x20)) as base.u32) | + ((0x02 & (args.bits >> 0x1F)) as base.u32) + if rgb0 >= rgb2 { + which |= 1 + } + delta = T_H_MODIFIERS[which] as base.u32 + + r[1] = CLAMP[((r[0] as base.u32) ~mod- delta) & 1023] + g[1] = CLAMP[((g[0] as base.u32) ~mod- delta) & 1023] + b[1] = CLAMP[((b[0] as base.u32) ~mod- delta) & 1023] + + r[0] = CLAMP[((r[0] as base.u32) ~mod+ delta) & 1023] + g[0] = CLAMP[((g[0] as base.u32) ~mod+ delta) & 1023] + b[0] = CLAMP[((b[0] as base.u32) ~mod+ delta) & 1023] + + r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023] + g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023] + b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023] + + r[2] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023] + g[2] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023] + b[2] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023] + + // Paint the 4×4 block. + + while y < 4 { + x = 0 + while x < 4, + inv y < 4, + { + x4y = (x * 4) | y + i = (((args.bits >> x4y) & 1) as base.u32) | + (((args.bits >> (x4y + 15)) & 2) as base.u32) + o = args.offset + (x * 4) + (y * 1024) + this.buffer[o + 0] = b[i] + this.buffer[o + 1] = g[i] + this.buffer[o + 2] = r[i] + x += 1 + } + y += 1 + } +} + +pri func decoder.decode_planar_mode!( + bits: base.u64, + offset: base.u32[..= 1008]) { + var ro : base.u32 + var go : base.u32 + var bo : base.u32 + var rh : base.u32 + var gh : base.u32 + var bh : base.u32 + var rv : base.u32 + var gv : base.u32 + var bv : base.u32 + + var y : base.u32 + var x : base.u32 + var o : base.u32[..= 4092] + var rp : base.u32 + var gp : base.u32 + var bp : base.u32 + + // Unjumble Planar-mode's 57 bits and convert from RGB676 to RGB888. + // + // 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec + // 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex + // .. Ro ro ro ro ro ro Go .. go go go go go go Bo .. .. .. bo bo .. bo bo bo Rh rh rh rh rh .. rh + // + // 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 dec + // 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 hex + // Gh gh gh gh gh gh gh Bh bh bh bh bh bh Rv rv rv rv rv rv Gv gv gv gv gv gv gv Bv bv bv bv bv bv + + ro = (0x3F & (args.bits >> 0x39)) as base.u32 + ro = (ro ~mod<< 2) | (ro >> 4) + go = ((0x40 & (args.bits >> 0x32)) as base.u32) | + ((0x3F & (args.bits >> 0x31)) as base.u32) + go = (go ~mod<< 1) | (go >> 6) + bo = ((0x20 & (args.bits >> 0x2B)) as base.u32) | + ((0x18 & (args.bits >> 0x28)) as base.u32) | + ((0x07 & (args.bits >> 0x27)) as base.u32) + bo = (bo ~mod<< 2) | (bo >> 4) + + rh = ((0x3E & (args.bits >> 0x21)) as base.u32) | + ((0x01 & (args.bits >> 0x20)) as base.u32) + rh = (rh ~mod<< 2) | (rh >> 4) + gh = (0x7F & (args.bits >> 0x19)) as base.u32 + gh = (gh ~mod<< 1) | (gh >> 6) + bh = (0x3F & (args.bits >> 0x13)) as base.u32 + bh = (bh ~mod<< 2) | (bh >> 4) + + rv = (0x3F & (args.bits >> 0x0D)) as base.u32 + rv = (rv ~mod<< 2) | (rv >> 4) + gv = (0x7F & (args.bits >> 0x06)) as base.u32 + gv = (gv ~mod<< 1) | (gv >> 6) + bv = (0x3F & (args.bits >> 0x00)) as base.u32 + bv = (bv ~mod<< 2) | (bv >> 4) + + // Convert h and v colors from absolute to relative. + + rh ~mod-= ro + gh ~mod-= go + bh ~mod-= bo + + rv ~mod-= ro + gv ~mod-= go + bv ~mod-= bo + + // Prepare to linearly interpolate (which involves dividing by 4). + + ro ~mod*= 4 + go ~mod*= 4 + bo ~mod*= 4 + + // Paint the 4×4 block. + + while y < 4 { + x = 0 + while x < 4, + inv y < 4, + { + o = args.offset + (x * 4) + (y * 1024) + bp = ((x ~mod* bh) ~mod+ (y ~mod* bv)) ~mod+ bo + this.buffer[o + 0] = CLAMP[((bp ~mod+ 2) / 4) & 1023] + gp = ((x ~mod* gh) ~mod+ (y ~mod* gv)) ~mod+ go + this.buffer[o + 1] = CLAMP[((gp ~mod+ 2) / 4) & 1023] + rp = ((x ~mod* rh) ~mod+ (y ~mod* rv)) ~mod+ ro + this.buffer[o + 2] = CLAMP[((rp ~mod+ 2) / 4) & 1023] + x += 1 + } + y += 1 + } +} + pri func decoder.decode_half_block!( bits: base.u32, offset: base.u32[..= 1008], @@ -507,6 +803,8 @@ pri const MODIFIERS : roarray[8] roarray[4] base.u32 = [ [0x0000_002F, 0x0000_00B7, 0xFFFF_FFD1, 0xFFFF_FF49], // [-183, -47, 47, 183] re-ordered. ] +pri const T_H_MODIFIERS : roarray[8] base.u8 = [3, 6, 11, 16, 23, 32, 41, 64] + pri const CLAMP : roarray[1024] base.u8 = [ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, diff --git a/test/nia-checksums-of-data.txt b/test/nia-checksums-of-data.txt index 2239e537..adedf776 100644 --- a/test/nia-checksums-of-data.txt +++ b/test/nia-checksums-of-data.txt @@ -26,6 +26,7 @@ OK. e08a7cc8 test/data/artificial-png/exif.png OK. e08a7cc8 test/data/artificial-png/key-value-pairs.png OK. 076cb375 test/data/bricks-color.bmp OK. bdbbfadb test/data/bricks-color.etc1.pkm +OK. 5670f263 test/data/bricks-color.etc2.pkm OK. 72a1f9cc test/data/bricks-color.jpeg OK. 076cb375 test/data/bricks-color.lossless.webp OK. 076cb375 test/data/bricks-color.png