diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 77113f22..b42735c8 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -6953,6 +6953,7 @@ struct wuffs_bzip2__decoder__struct { struct { uint32_t f_scratch; + uint32_t f_letter_counts[256]; uint8_t f_presence[256]; uint8_t f_mtft[256]; uint8_t f_huffman_selectors[32768]; @@ -25847,6 +25848,11 @@ wuffs_bzip2__decoder__execute_block( } v_i += 1; } + v_i = 0; + while (v_i < 256) { + self->private_data.f_letter_counts[v_i] = 0; + v_i += 1; + } v_ticks = 50; while (true) { if (v_ticks > 0) { @@ -25883,6 +25889,7 @@ wuffs_bzip2__decoder__execute_block( v_output = ((uint32_t)(self->private_data.f_mtft[v_child_ff])); wuffs_base__slice_u8__copy_from_slice(wuffs_base__make_slice_u8_ij(self->private_data.f_mtft, 1, (1 + v_child_ff)), wuffs_base__make_slice_u8(self->private_data.f_mtft, v_child_ff)); self->private_data.f_mtft[0] = ((uint8_t)(v_output)); + self->private_data.f_letter_counts[v_output] += 1; self->private_data.f_bwt[v_bs] = v_output; if (v_bs >= self->private_impl.f_max_incl_block_size) { status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length); @@ -25908,6 +25915,7 @@ wuffs_bzip2__decoder__execute_block( } v_bs = v_j; v_mtft0 = ((uint32_t)(self->private_data.f_mtft[0])); + self->private_data.f_letter_counts[v_mtft0] += v_run; while (v_i < v_j) { self->private_data.f_bwt[v_i] = v_mtft0; v_i += 1; @@ -25955,29 +25963,22 @@ wuffs_bzip2__decoder__invert_bwt( wuffs_bzip2__decoder* self) { uint32_t v_i = 0; uint32_t v_letter = 0; - uint32_t v_counts[256] = {0}; uint32_t v_sum = 0; uint32_t v_old_sum = 0; - v_i = 0; - while (v_i < self->private_impl.f_block_size) { - v_letter = (self->private_data.f_bwt[v_i] & 255); - v_counts[v_letter] += 1; - v_i += 1; - } v_sum = 0; v_i = 0; while (v_i < 256) { v_old_sum = v_sum; - v_sum += v_counts[v_i]; - v_counts[v_i] = v_old_sum; + v_sum += self->private_data.f_letter_counts[v_i]; + self->private_data.f_letter_counts[v_i] = v_old_sum; v_i += 1; } v_i = 0; while (v_i < self->private_impl.f_block_size) { v_letter = (self->private_data.f_bwt[v_i] & 255); - self->private_data.f_bwt[(v_counts[v_letter] & 1048575)] |= (v_i << 12); - v_counts[v_letter] += 1; + self->private_data.f_bwt[(self->private_data.f_letter_counts[v_letter] & 1048575)] |= (v_i << 12); + self->private_data.f_letter_counts[v_letter] += 1; v_i += 1; } return wuffs_base__make_empty_struct(); diff --git a/std/bzip2/decode_bzip2.wuffs b/std/bzip2/decode_bzip2.wuffs index 8da8d777..8052827c 100644 --- a/std/bzip2/decode_bzip2.wuffs +++ b/std/bzip2/decode_bzip2.wuffs @@ -47,6 +47,8 @@ pub struct decoder? implements base.io_transformer( )( scratch : base.u32, + letter_counts : array[256] base.u32, + // presence[i] being non-zero is whether the byte value i occurs in the // block's decompressed output. presence : array[256] base.u8, @@ -602,7 +604,7 @@ pri func decoder.execute_block?(src: base.io_reader) { var node_index : base.u32[..= 1023] var run_shift : base.u32[..= 23] var run : base.u32[..= 16_777216] // 16_777216 = (2 << 23) - var mtft0 : base.u32 + var mtft0 : base.u32[..= 255] which = CLAMP_TO_5[this.huffman_selectors[0] & 7] section = 1 @@ -618,6 +620,12 @@ pri func decoder.execute_block?(src: base.io_reader) { i += 1 } endwhile + i = 0 + while i < 256 { + this.letter_counts[i] = 0 + i += 1 + } endwhile + // Apply the Huffman trees. ticks = 50 while.outer true { @@ -653,6 +661,7 @@ pri func decoder.execute_block?(src: base.io_reader) { s: this.mtft[.. child_ff]) this.mtft[0] = output as base.u8 + this.letter_counts[output] ~mod+= 1 this.bwt[bs] = output if bs >= this.max_incl_block_size { return "#bad block length" @@ -681,6 +690,7 @@ pri func decoder.execute_block?(src: base.io_reader) { bs = j mtft0 = this.mtft[0] as base.u32 + this.letter_counts[mtft0] ~mod+= run while i < j, pre j <= 900000, { @@ -700,30 +710,21 @@ pri func decoder.execute_block?(src: base.io_reader) { } // invert_bwt performs "two passes over the data, and one pass over the -// alphabet", per the BWT technical report. +// alphabet", per the BWT technical report, except that the first data pass +// (accumulating this.letter_counts) is integrated into execute_block. pri func decoder.invert_bwt!() { var i : base.u32 var letter : base.u32[..= 255] - var counts : array[256] base.u32 var sum : base.u32 var old_sum : base.u32 - // First data pass. - i = 0 - while i < this.block_size { - assert i < 900000 via "a < b: a < c; c <= b"(c: this.block_size) - letter = this.bwt[i] & 0xFF - counts[letter] ~mod+= 1 - i += 1 - } endwhile - // Alphabet pass. sum = 0 i = 0 while i < 256 { old_sum = sum - sum ~mod+= counts[i] - counts[i] = old_sum + sum ~mod+= this.letter_counts[i] + this.letter_counts[i] = old_sum i += 1 } endwhile @@ -733,8 +734,8 @@ pri func decoder.invert_bwt!() { while i < this.block_size { assert i < 900000 via "a < b: a < c; c <= b"(c: this.block_size) letter = this.bwt[i] & 0xFF - this.bwt[counts[letter] & 1_048575] |= i << 12 - counts[letter] ~mod+= 1 + this.bwt[this.letter_counts[letter] & 1_048575] |= i << 12 + this.letter_counts[letter] ~mod+= 1 i += 1 } endwhile }