diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 8b7460b1..b73c8fd2 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -6789,6 +6789,17 @@ struct wuffs_bmp__decoder__struct { // ---------------- Status Codes +extern const char wuffs_bzip2__error__bad_huffman_code_over_subscribed[]; +extern const char wuffs_bzip2__error__bad_huffman_code_under_subscribed[]; +extern const char wuffs_bzip2__error__bad_block_header[]; +extern const char wuffs_bzip2__error__bad_block_length[]; +extern const char wuffs_bzip2__error__bad_checksum[]; +extern const char wuffs_bzip2__error__bad_header[]; +extern const char wuffs_bzip2__error__bad_number_of_huffman_codes[]; +extern const char wuffs_bzip2__error__bad_number_of_sections[]; +extern const char wuffs_bzip2__error__unsupported_huffman_code[]; +extern const char wuffs_bzip2__error__unsupported_block_randomization[]; + // ---------------- Public Consts #define WUFFS_BZIP2__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0 @@ -6889,14 +6900,63 @@ struct wuffs_bzip2__decoder__struct { wuffs_base__vtable vtable_for__wuffs_base__io_transformer; wuffs_base__vtable null_vtable; + uint32_t f_bits; + uint32_t f_n_bits; + uint32_t f_block_size; + uint32_t f_max_incl_block_size; + uint32_t f_final_checksum_have; + uint32_t f_block_checksum_want; + uint32_t f_original_pointer; + uint32_t f_num_symbols; + uint32_t f_num_huffman_codes; + uint32_t f_num_sections; + uint32_t f_code_lengths_bitmask; uint32_t p_transform_io[1]; + uint32_t p_prepare_block[1]; + uint32_t p_read_code_lengths[1]; + uint32_t p_execute_block[1]; + uint32_t p_flush_block[1]; } private_impl; struct { + uint32_t f_scratch; + uint8_t f_presence[256]; + uint8_t f_mtft[256]; + uint8_t f_huffman_selectors[32768]; + uint16_t f_huffman_trees[6][1024][2]; + uint32_t f_bwt[1048576]; + struct { - uint64_t scratch; + uint32_t v_i; + uint64_t v_tag; + uint32_t v_final_checksum_want; } s_transform_io[1]; + struct { + uint32_t v_i; + uint32_t v_selector; + } s_prepare_block[1]; + struct { + uint32_t v_i; + uint32_t v_code_length; + } s_read_code_lengths[1]; + struct { + uint8_t v_which; + uint32_t v_ticks; + uint32_t v_section; + uint32_t v_bs; + uint32_t v_node_index; + uint32_t v_run_shift; + } s_execute_block[1]; + struct { + uint32_t v_i; + uint32_t v_n; + uint32_t v_repeat_count; + uint32_t v_block_checksum_have; + uint8_t v_prev; + uint8_t v_curr; + uint64_t scratch; + } s_flush_block[1]; } private_data; #ifdef __cplusplus @@ -24761,12 +24821,93 @@ wuffs_bmp__decoder__process_masks( // ---------------- Status Codes Implementations +const char wuffs_bzip2__error__bad_huffman_code_over_subscribed[] = "#bzip2: bad Huffman code (over-subscribed)"; +const char wuffs_bzip2__error__bad_huffman_code_under_subscribed[] = "#bzip2: bad Huffman code (under-subscribed)"; +const char wuffs_bzip2__error__bad_block_header[] = "#bzip2: bad block header"; +const char wuffs_bzip2__error__bad_block_length[] = "#bzip2: bad block length"; +const char wuffs_bzip2__error__bad_checksum[] = "#bzip2: bad checksum"; +const char wuffs_bzip2__error__bad_header[] = "#bzip2: bad header"; +const char wuffs_bzip2__error__bad_number_of_huffman_codes[] = "#bzip2: bad number of Huffman codes"; +const char wuffs_bzip2__error__bad_number_of_sections[] = "#bzip2: bad number of sections"; +const char wuffs_bzip2__error__unsupported_huffman_code[] = "#bzip2: unsupported Huffman code"; +const char wuffs_bzip2__error__unsupported_block_randomization[] = "#bzip2: unsupported block randomization"; + // ---------------- Private Consts +static const uint8_t +WUFFS_BZIP2__CLAMP_TO_5[8] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0, 1, 2, 3, 4, 5, 5, 5, +}; + +static const uint32_t +WUFFS_BZIP2__REV_CRC32_TABLE[256] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0, 79764919, 159529838, 222504665, 319059676, 398814059, 445009330, 507990021, + 638119352, 583659535, 797628118, 726387553, 890018660, 835552979, 1015980042, 944750013, + 1276238704, 1221641927, 1167319070, 1095957929, 1595256236, 1540665371, 1452775106, 1381403509, + 1780037320, 1859660671, 1671105958, 1733955601, 2031960084, 2111593891, 1889500026, 1952343757, + 2552477408, 2632100695, 2443283854, 2506133561, 2334638140, 2414271883, 2191915858, 2254759653, + 3190512472, 3135915759, 3081330742, 3009969537, 2905550212, 2850959411, 2762807018, 2691435357, + 3560074640, 3505614887, 3719321342, 3648080713, 3342211916, 3287746299, 3467911202, 3396681109, + 4063920168, 4143685023, 4223187782, 4286162673, 3779000052, 3858754371, 3904687514, 3967668269, + 881225847, 809987520, 1023691545, 969234094, 662832811, 591600412, 771767749, 717299826, + 311336399, 374308984, 453813921, 533576470, 25881363, 88864420, 134795389, 214552010, + 2023205639, 2086057648, 1897238633, 1976864222, 1804852699, 1867694188, 1645340341, 1724971778, + 1587496639, 1516133128, 1461550545, 1406951526, 1302016099, 1230646740, 1142491917, 1087903418, + 2896545431, 2825181984, 2770861561, 2716262478, 3215044683, 3143675388, 3055782693, 3001194130, + 2326604591, 2389456536, 2200899649, 2280525302, 2578013683, 2640855108, 2418763421, 2498394922, + 3769900519, 3832873040, 3912640137, 3992402750, 4088425275, 4151408268, 4197601365, 4277358050, + 3334271071, 3263032808, 3476998961, 3422541446, 3585640067, 3514407732, 3694837229, 3640369242, + 1762451694, 1842216281, 1619975040, 1682949687, 2047383090, 2127137669, 1938468188, 2001449195, + 1325665622, 1271206113, 1183200824, 1111960463, 1543535498, 1489069629, 1434599652, 1363369299, + 622672798, 568075817, 748617968, 677256519, 907627842, 853037301, 1067152940, 995781531, + 51762726, 131386257, 177728840, 240578815, 269590778, 349224269, 429104020, 491947555, + 4046411278, 4126034873, 4172115296, 4234965207, 3794477266, 3874110821, 3953728444, 4016571915, + 3609705398, 3555108353, 3735388376, 3664026991, 3290680682, 3236090077, 3449943556, 3378572211, + 3174993278, 3120533705, 3032266256, 2961025959, 2923101090, 2868635157, 2813903052, 2742672763, + 2604032198, 2683796849, 2461293480, 2524268063, 2284983834, 2364738477, 2175806836, 2238787779, + 1569362073, 1498123566, 1409854455, 1355396672, 1317987909, 1246755826, 1192025387, 1137557660, + 2072149281, 2135122070, 1912620623, 1992383480, 1753615357, 1816598090, 1627664531, 1707420964, + 295390185, 358241886, 404320391, 483945776, 43990325, 106832002, 186451547, 266083308, + 932423249, 861060070, 1041341759, 986742920, 613929101, 542559546, 756411363, 701822548, + 3316196985, 3244833742, 3425377559, 3370778784, 3601682597, 3530312978, 3744426955, 3689838204, + 3819031489, 3881883254, 3928223919, 4007849240, 4037393693, 4100235434, 4180117107, 4259748804, + 2310601993, 2373574846, 2151335527, 2231098320, 2596047829, 2659030626, 2470359227, 2550115596, + 2947551409, 2876312838, 2788305887, 2733848168, 3165939309, 3094707162, 3040238851, 2985771188, +}; + // ---------------- Private Initializer Prototypes // ---------------- Private Function Prototypes +static wuffs_base__status +wuffs_bzip2__decoder__prepare_block( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_src); + +static wuffs_base__status +wuffs_bzip2__decoder__read_code_lengths( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_src); + +static wuffs_base__status +wuffs_bzip2__decoder__build_huffman_tree( + wuffs_bzip2__decoder* self, + uint32_t a_which); + +static wuffs_base__status +wuffs_bzip2__decoder__execute_block( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_src); + +static wuffs_base__empty_struct +wuffs_bzip2__decoder__invert_bwt( + wuffs_bzip2__decoder* self); + +static wuffs_base__status +wuffs_bzip2__decoder__flush_block( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_dst); + // ---------------- VTables const wuffs_base__io_transformer__func_ptrs @@ -24907,6 +25048,925 @@ wuffs_bzip2__decoder__transform_io( self->private_impl.active_coroutine = 0; wuffs_base__status status = wuffs_base__make_status(NULL); + uint8_t v_c = 0; + uint32_t v_i = 0; + uint64_t v_tag = 0; + uint32_t v_final_checksum_want = 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) { + 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_transform_io[0]; + if (coro_susp_point) { + v_i = self->private_data.s_transform_io[0].v_i; + v_tag = self->private_data.s_transform_io[0].v_tag; + v_final_checksum_want = self->private_data.s_transform_io[0].v_final_checksum_want; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c = t_0; + } + if (v_c != 66) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_header); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c = t_1; + } + if (v_c != 90) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_header); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c = t_2; + } + if (v_c != 104) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_header); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_3 = *iop_a_src++; + v_c = t_3; + } + if ((v_c < 49) || (57 < v_c)) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_header); + goto exit; + } + self->private_impl.f_max_incl_block_size = (((uint32_t)((v_c - 48))) * 100000); + while (true) { + v_tag = 0; + v_i = 0; + while (v_i < 48) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_4 = *iop_a_src++; + v_c = t_4; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + v_tag <<= 1; + v_tag |= ((uint64_t)((self->private_impl.f_bits >> 31))); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + if (v_tag == 25779555029136) { + goto label__0__break; + } else if (v_tag != 54156738319193) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header); + goto exit; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + status = wuffs_bzip2__decoder__prepare_block(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + status = wuffs_bzip2__decoder__execute_block(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + wuffs_bzip2__decoder__invert_bwt(self); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + status = wuffs_bzip2__decoder__flush_block(self, a_dst); + if (status.repr) { + goto suspend; + } + } + label__0__break:; + v_final_checksum_want = 0; + v_i = 0; + while (v_i < 32) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_5 = *iop_a_src++; + v_c = t_5; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + v_final_checksum_want <<= 1; + v_final_checksum_want |= (self->private_impl.f_bits >> 31); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + if (self->private_impl.f_final_checksum_have != v_final_checksum_want) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_checksum); + goto exit; + } + + goto ok; + ok: + self->private_impl.p_transform_io[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_transform_io[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0; + self->private_data.s_transform_io[0].v_i = v_i; + self->private_data.s_transform_io[0].v_tag = v_tag; + self->private_data.s_transform_io[0].v_final_checksum_want = v_final_checksum_want; + + goto exit; + exit: + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + if (wuffs_base__status__is_error(&status)) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + } + return status; +} + +// -------- func bzip2.decoder.prepare_block + +static wuffs_base__status +wuffs_bzip2__decoder__prepare_block( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c = 0; + uint32_t v_i = 0; + uint32_t v_selector = 0; + uint32_t v_sel_ff = 0; + uint8_t v_movee = 0; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + + 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) { + 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_prepare_block[0]; + if (coro_susp_point) { + v_i = self->private_data.s_prepare_block[0].v_i; + v_selector = self->private_data.s_prepare_block[0].v_selector; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + self->private_impl.f_block_checksum_want = 0; + v_i = 0; + while (v_i < 32) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c = t_0; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + self->private_impl.f_block_checksum_want <<= 1; + self->private_impl.f_block_checksum_want |= (self->private_impl.f_bits >> 31); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c = t_1; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + if ((self->private_impl.f_bits >> 31) != 0) { + status = wuffs_base__make_status(wuffs_bzip2__error__unsupported_block_randomization); + goto exit; + } + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + self->private_impl.f_original_pointer = 0; + v_i = 0; + while (v_i < 24) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c = t_2; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + self->private_impl.f_original_pointer <<= 1; + self->private_impl.f_original_pointer |= (self->private_impl.f_bits >> 31); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + v_i = 0; + while (v_i < 256) { + self->private_data.f_presence[v_i] = 0; + v_i += 1; + } + v_i = 0; + while (v_i < 256) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_3 = *iop_a_src++; + v_c = t_3; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + if ((self->private_impl.f_bits >> 31) != 0) { + self->private_data.f_presence[v_i] = 1; + } + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 16; + } + self->private_data.f_scratch = 0; + v_i = 0; + label__0__continue:; + while (v_i < 256) { + if (self->private_data.f_presence[v_i] == 0) { + v_i += 16; + goto label__0__continue; + } + while (true) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_4 = *iop_a_src++; + v_c = t_4; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + self->private_data.f_scratch += (self->private_impl.f_bits >> 31); + self->private_data.f_presence[(v_i & 255)] = ((uint8_t)((self->private_impl.f_bits >> 31))); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + if ((v_i & 15) == 0) { + goto label__1__break; + } + } + label__1__break:; + } + if ((self->private_data.f_scratch < 1) || (256 < self->private_data.f_scratch)) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header); + goto exit; + } + self->private_impl.f_num_symbols = (self->private_data.f_scratch + 2); + self->private_data.f_scratch = 0; + v_i = 0; + while (v_i < 3) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_5 = *iop_a_src++; + v_c = t_5; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + self->private_data.f_scratch <<= 1; + self->private_data.f_scratch |= (self->private_impl.f_bits >> 31); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + if ((self->private_data.f_scratch < 2) || (6 < self->private_data.f_scratch)) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header); + goto exit; + } + self->private_impl.f_num_huffman_codes = self->private_data.f_scratch; + self->private_data.f_scratch = 0; + v_i = 0; + while (v_i < 15) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_6 = *iop_a_src++; + v_c = t_6; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + self->private_data.f_scratch <<= 1; + self->private_data.f_scratch |= (self->private_impl.f_bits >> 31); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + if ((self->private_data.f_scratch < 1) || (18001 < self->private_data.f_scratch)) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header); + goto exit; + } + self->private_impl.f_num_sections = self->private_data.f_scratch; + v_i = 0; + while (v_i < self->private_impl.f_num_huffman_codes) { + self->private_data.f_mtft[v_i] = ((uint8_t)(v_i)); + v_i += 1; + } + v_i = 0; + while (v_i < self->private_impl.f_num_sections) { + v_selector = 0; + while (true) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_7 = *iop_a_src++; + v_c = t_7; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + if ((self->private_impl.f_bits >> 31) == 0) { + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + goto label__2__break; + } + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_selector += 1; + if (v_selector >= self->private_impl.f_num_huffman_codes) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header); + goto exit; + } + } + label__2__break:; + if (v_selector == 0) { + self->private_data.f_huffman_selectors[v_i] = self->private_data.f_mtft[0]; + } else { + v_sel_ff = (v_selector & 255); + v_movee = self->private_data.f_mtft[v_sel_ff]; + wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8((self->private_data.f_mtft) + 1, 255), (1 + v_sel_ff)), wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_mtft, 256), v_sel_ff)); + self->private_data.f_mtft[0] = v_movee; + self->private_data.f_huffman_selectors[v_i] = v_movee; + } + v_i += 1; + } + v_i = 0; + while (v_i < self->private_impl.f_num_huffman_codes) { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + status = wuffs_bzip2__decoder__read_code_lengths(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + v_status = wuffs_bzip2__decoder__build_huffman_tree(self, v_i); + if (wuffs_base__status__is_error(&v_status)) { + status = v_status; + goto exit; + } + v_i += 1; + } + + goto ok; + ok: + self->private_impl.p_prepare_block[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_prepare_block[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_prepare_block[0].v_i = v_i; + self->private_data.s_prepare_block[0].v_selector = v_selector; + + goto exit; + exit: + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func bzip2.decoder.read_code_lengths + +static wuffs_base__status +wuffs_bzip2__decoder__read_code_lengths( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c = 0; + uint32_t v_i = 0; + uint32_t v_code_length = 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) { + 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_read_code_lengths[0]; + if (coro_susp_point) { + v_i = self->private_data.s_read_code_lengths[0].v_i; + v_code_length = self->private_data.s_read_code_lengths[0].v_code_length; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + self->private_impl.f_code_lengths_bitmask = 0; + v_i = 0; + while (v_i < 5) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c = t_0; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + v_code_length <<= 1; + v_code_length |= (self->private_impl.f_bits >> 31); + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + v_i += 1; + } + v_i = 0; + while (v_i < self->private_impl.f_num_symbols) { + while (true) { + if ((v_code_length < 1) || (20 < v_code_length)) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_header); + goto exit; + } + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_1 = *iop_a_src++; + v_c = t_1; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + if ((self->private_impl.f_bits >> 31) == 0) { + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + goto label__0__break; + } + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_2 = *iop_a_src++; + v_c = t_2; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + if ((self->private_impl.f_bits >> 31) == 0) { + v_code_length += 1; + } else { + v_code_length -= 1; + } + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + } + label__0__break:; + self->private_impl.f_code_lengths_bitmask |= (((uint32_t)(1)) << (v_code_length & 31)); + self->private_data.f_bwt[v_i] = v_code_length; + v_i += 1; + } + + goto ok; + ok: + self->private_impl.p_read_code_lengths[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_read_code_lengths[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_read_code_lengths[0].v_i = v_i; + self->private_data.s_read_code_lengths[0].v_code_length = v_code_length; + + goto exit; + exit: + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func bzip2.decoder.build_huffman_tree + +static wuffs_base__status +wuffs_bzip2__decoder__build_huffman_tree( + wuffs_bzip2__decoder* self, + uint32_t a_which) { + uint32_t v_code_length = 0; + uint32_t v_symbol_index = 0; + uint32_t v_num_nodes = 0; + uint32_t v_stack_height = 0; + uint32_t v_stack_values[21] = {0}; + uint32_t v_node_index = 0; + uint16_t v_leaf_value = 0; + + self->private_data.f_huffman_trees[a_which][0][0] = 0; + self->private_data.f_huffman_trees[a_which][0][1] = 0; + v_num_nodes = 1; + v_stack_height = 1; + v_stack_values[0] = 0; + v_code_length = 1; + label__0__continue:; + while (v_code_length <= 20) { + if ((self->private_impl.f_code_lengths_bitmask & (((uint32_t)(1)) << v_code_length)) == 0) { + v_code_length += 1; + goto label__0__continue; + } + v_symbol_index = 0; + label__1__continue:; + while (v_symbol_index < self->private_impl.f_num_symbols) { + if (self->private_data.f_bwt[v_symbol_index] != v_code_length) { + v_symbol_index += 1; + goto label__1__continue; + } + while (true) { + if (v_stack_height <= 0) { + return wuffs_base__make_status(wuffs_bzip2__error__bad_huffman_code_over_subscribed); + } else if (v_stack_height >= v_code_length) { + goto label__2__break; + } + v_node_index = v_stack_values[(v_stack_height - 1)]; + if (self->private_data.f_huffman_trees[a_which][v_node_index][0] == 0) { + self->private_data.f_huffman_trees[a_which][v_node_index][0] = ((uint16_t)(v_num_nodes)); + } else { + self->private_data.f_huffman_trees[a_which][v_node_index][1] = ((uint16_t)(v_num_nodes)); + } + if (v_num_nodes >= 1023) { + return wuffs_base__make_status(wuffs_bzip2__error__unsupported_huffman_code); + } + v_stack_values[v_stack_height] = v_num_nodes; + self->private_data.f_huffman_trees[a_which][v_num_nodes][0] = 0; + self->private_data.f_huffman_trees[a_which][v_num_nodes][1] = 0; + v_num_nodes += 1; + v_stack_height += 1; + } + label__2__break:; + v_node_index = v_stack_values[(v_stack_height - 1)]; + if (v_symbol_index < 2) { + v_leaf_value = ((uint16_t)((1280 + v_symbol_index))); + } else if ((v_symbol_index + 1) < self->private_impl.f_num_symbols) { + v_leaf_value = ((uint16_t)((1023 + v_symbol_index))); + } else { + v_leaf_value = 2047; + } + if (self->private_data.f_huffman_trees[a_which][v_node_index][0] == 0) { + self->private_data.f_huffman_trees[a_which][v_node_index][0] = v_leaf_value; + } else { + self->private_data.f_huffman_trees[a_which][v_node_index][1] = v_leaf_value; + v_stack_height -= 1; + while (v_stack_height > 0) { + v_node_index = v_stack_values[(v_stack_height - 1)]; + if (self->private_data.f_huffman_trees[a_which][v_node_index][1] == 0) { + goto label__3__break; + } + v_stack_height -= 1; + } + label__3__break:; + } + v_symbol_index += 1; + } + v_code_length += 1; + } + if (v_stack_height != 0) { + return wuffs_base__make_status(wuffs_bzip2__error__bad_huffman_code_under_subscribed); + } + return wuffs_base__make_status(NULL); +} + +// -------- func bzip2.decoder.execute_block + +static wuffs_base__status +wuffs_bzip2__decoder__execute_block( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_which = 0; + uint8_t v_c = 0; + uint16_t v_child = 0; + uint32_t v_child_ff = 0; + uint32_t v_i = 0; + uint32_t v_j = 0; + uint32_t v_ticks = 0; + uint32_t v_section = 0; + uint32_t v_bs = 0; + uint32_t v_output = 0; + uint32_t v_node_index = 0; + uint32_t v_run_shift = 0; + uint32_t v_run = 0; + uint32_t v_mtft0 = 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) { + 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_execute_block[0]; + if (coro_susp_point) { + v_which = self->private_data.s_execute_block[0].v_which; + v_ticks = self->private_data.s_execute_block[0].v_ticks; + v_section = self->private_data.s_execute_block[0].v_section; + v_bs = self->private_data.s_execute_block[0].v_bs; + v_node_index = self->private_data.s_execute_block[0].v_node_index; + v_run_shift = self->private_data.s_execute_block[0].v_run_shift; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_which = WUFFS_BZIP2__CLAMP_TO_5[(self->private_data.f_huffman_selectors[0] & 7)]; + v_section = 1; + v_i = 0; + v_j = 0; + while (v_i < 256) { + if (self->private_data.f_presence[v_i] != 0) { + self->private_data.f_mtft[(v_j & 255)] = ((uint8_t)(v_i)); + v_j += 1; + } + v_i += 1; + } + v_ticks = 50; + while (true) { + if (v_ticks > 0) { + v_ticks -= 1; + } else { + v_ticks = 49; + v_which = WUFFS_BZIP2__CLAMP_TO_5[(self->private_data.f_huffman_selectors[(v_section & 32767)] & 7)]; + v_section += 1; + } + v_node_index = 0; + label__0__continue:; + while (true) { + if (self->private_impl.f_n_bits <= 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c = t_0; + } + self->private_impl.f_bits = (((uint32_t)(v_c)) << 24); + self->private_impl.f_n_bits = 8; + } + v_child = self->private_data.f_huffman_trees[v_which][v_node_index][(self->private_impl.f_bits >> 31)]; + self->private_impl.f_bits <<= 1; + self->private_impl.f_n_bits -= 1; + if (v_child < 1024) { + v_node_index = ((uint32_t)(v_child)); + goto label__0__continue; + } else if (v_child < 1280) { + v_child_ff = ((uint32_t)((v_child & 255))); + v_output = ((uint32_t)(self->private_data.f_mtft[v_child_ff])); + wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8((self->private_data.f_mtft) + 1, 255), (1 + v_child_ff)), wuffs_base__slice_u8__subslice_j(wuffs_base__make_slice_u8(self->private_data.f_mtft, 256), v_child_ff)); + self->private_data.f_mtft[0] = ((uint8_t)(v_output)); + 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); + goto exit; + } + v_bs += 1; + v_run_shift = 0; + goto label__0__break; + } else if (v_child > 1281) { + goto label__outer__break; + } + if (v_run_shift >= 23) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length); + goto exit; + } + v_run = (((uint32_t)((v_child - 1279))) << v_run_shift); + v_run_shift += 1; + v_i = v_bs; + v_j = (v_run + v_bs); + if (v_j > self->private_impl.f_max_incl_block_size) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length); + goto exit; + } + v_bs = v_j; + v_mtft0 = ((uint32_t)(self->private_data.f_mtft[0])); + while (v_i < v_j) { + self->private_data.f_bwt[v_i] = v_mtft0; + v_i += 1; + } + goto label__0__break; + } + label__0__break:; + } + label__outer__break:; + if (v_bs > self->private_impl.f_max_incl_block_size) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length); + goto exit; + } + self->private_impl.f_block_size = v_bs; + + goto ok; + ok: + self->private_impl.p_execute_block[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_execute_block[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_execute_block[0].v_which = v_which; + self->private_data.s_execute_block[0].v_ticks = v_ticks; + self->private_data.s_execute_block[0].v_section = v_section; + self->private_data.s_execute_block[0].v_bs = v_bs; + self->private_data.s_execute_block[0].v_node_index = v_node_index; + self->private_data.s_execute_block[0].v_run_shift = v_run_shift; + + goto exit; + exit: + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + +// -------- func bzip2.decoder.invert_bwt + +static wuffs_base__empty_struct +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_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; + v_i += 1; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func bzip2.decoder.flush_block + +static wuffs_base__status +wuffs_bzip2__decoder__flush_block( + wuffs_bzip2__decoder* self, + wuffs_base__io_buffer* a_dst) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_i = 0; + uint32_t v_n = 0; + uint32_t v_entry = 0; + uint32_t v_repeat_count = 0; + uint32_t v_block_checksum_have = 0; + uint8_t v_prev = 0; + uint8_t v_curr = 0; + uint8_t* iop_a_dst = NULL; uint8_t* io0_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; uint8_t* io1_a_dst WUFFS_BASE__POTENTIALLY_UNUSED = NULL; @@ -24920,70 +25980,97 @@ wuffs_bzip2__decoder__transform_io( io2_a_dst = iop_a_dst; } } - 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) { - 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_transform_io[0]; + uint32_t coro_susp_point = self->private_impl.p_flush_block[0]; + if (coro_susp_point) { + v_i = self->private_data.s_flush_block[0].v_i; + v_n = self->private_data.s_flush_block[0].v_n; + v_repeat_count = self->private_data.s_flush_block[0].v_repeat_count; + v_block_checksum_have = self->private_data.s_flush_block[0].v_block_checksum_have; + v_prev = self->private_data.s_flush_block[0].v_prev; + v_curr = self->private_data.s_flush_block[0].v_curr; + } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - while (true) { - if (((uint64_t)(io2_a_src - iop_a_src)) > 0) { - self->private_data.s_transform_io[0].scratch = ((uint64_t)(io2_a_src - iop_a_src)); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - if (self->private_data.s_transform_io[0].scratch > ((uint64_t)(io2_a_src - iop_a_src))) { - self->private_data.s_transform_io[0].scratch -= ((uint64_t)(io2_a_src - iop_a_src)); - iop_a_src = io2_a_src; - status = wuffs_base__make_status(wuffs_base__suspension__short_read); + if (self->private_impl.f_original_pointer >= self->private_impl.f_block_size) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_block_length); + goto exit; + } + v_i = (self->private_data.f_bwt[self->private_impl.f_original_pointer] >> 12); + v_block_checksum_have = 4294967295; + v_n = 0; + while (v_n < self->private_impl.f_block_size) { + v_entry = self->private_data.f_bwt[v_i]; + v_curr = ((uint8_t)((v_entry & 255))); + v_i = (v_entry >> 12); + if (v_repeat_count >= 4) { + v_repeat_count = ((uint32_t)(v_curr)); + while (v_repeat_count > 0) { + v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_prev)] ^ ((uint32_t)(v_block_checksum_have << 8))); + self->private_data.s_flush_block[0].scratch = v_prev; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + if (iop_a_dst == io2_a_dst) { + status = wuffs_base__make_status(wuffs_base__suspension__short_write); + goto suspend; + } + *iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_block[0].scratch)); + v_repeat_count -= 1; + } + v_repeat_count = 0; + } else if (v_curr != v_prev) { + v_repeat_count = 1; + v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8))); + self->private_data.s_flush_block[0].scratch = v_curr; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (iop_a_dst == io2_a_dst) { + status = wuffs_base__make_status(wuffs_base__suspension__short_write); goto suspend; } - iop_a_src += self->private_data.s_transform_io[0].scratch; + *iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_block[0].scratch)); + } else { + v_repeat_count += 1; + v_block_checksum_have = (WUFFS_BZIP2__REV_CRC32_TABLE[(((uint8_t)((v_block_checksum_have >> 24))) ^ v_curr)] ^ ((uint32_t)(v_block_checksum_have << 8))); + self->private_data.s_flush_block[0].scratch = v_curr; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + if (iop_a_dst == io2_a_dst) { + status = wuffs_base__make_status(wuffs_base__suspension__short_write); + goto suspend; + } + *iop_a_dst++ = ((uint8_t)(self->private_data.s_flush_block[0].scratch)); } - if (a_src && a_src->meta.closed) { - goto label__0__break; - } - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); + v_prev = v_curr; + v_n += 1; } - label__0__break:; - self->private_data.s_transform_io[0].scratch = 66; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); - if (iop_a_dst == io2_a_dst) { - status = wuffs_base__make_status(wuffs_base__suspension__short_write); - goto suspend; + v_block_checksum_have ^= 4294967295; + if (v_block_checksum_have != self->private_impl.f_block_checksum_want) { + status = wuffs_base__make_status(wuffs_bzip2__error__bad_checksum); + goto exit; } - *iop_a_dst++ = ((uint8_t)(self->private_data.s_transform_io[0].scratch)); + self->private_impl.f_final_checksum_have = (v_block_checksum_have ^ ((self->private_impl.f_final_checksum_have >> 31) | ((uint32_t)(self->private_impl.f_final_checksum_have << 1)))); + goto ok; ok: - self->private_impl.p_transform_io[0] = 0; + self->private_impl.p_flush_block[0] = 0; goto exit; } goto suspend; suspend: - self->private_impl.p_transform_io[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0; + self->private_impl.p_flush_block[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_flush_block[0].v_i = v_i; + self->private_data.s_flush_block[0].v_n = v_n; + self->private_data.s_flush_block[0].v_repeat_count = v_repeat_count; + self->private_data.s_flush_block[0].v_block_checksum_have = v_block_checksum_have; + self->private_data.s_flush_block[0].v_prev = v_prev; + self->private_data.s_flush_block[0].v_curr = v_curr; goto exit; exit: if (a_dst) { a_dst->meta.wi = ((size_t)(iop_a_dst - a_dst->data.ptr)); } - if (a_src) { - a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); - } - if (wuffs_base__status__is_error(&status)) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - } return status; } diff --git a/script/print-crc32-magic-numbers.go b/script/print-crc32-magic-numbers.go index 740b62e8..1c3c2727 100644 --- a/script/print-crc32-magic-numbers.go +++ b/script/print-crc32-magic-numbers.go @@ -22,11 +22,16 @@ package main // Usage: go run print-crc32-magic-numbers.go import ( + "flag" "fmt" "hash/crc32" "os" ) +var ( + reverse = flag.Bool("reverse", false, "whether to reverse the bits") +) + func main() { if err := main1(); err != nil { os.Stderr.WriteString(err.Error() + "\n") @@ -35,6 +40,7 @@ func main() { } func main1() error { + flag.Parse() tables := [16]crc32.Table{} tables[0] = *crc32.MakeTable(crc32.IEEE) @@ -49,6 +55,9 @@ func main1() error { } for i, t := range tables { + if *reverse { + reverseTable(&t) + } if i != 0 { fmt.Println("],[") } @@ -61,3 +70,55 @@ func main1() error { } return nil } + +// reverseTable reverses the bits in the keys and values of a crc32.Table +// (which is a [256]uint32). +func reverseTable(t *crc32.Table) { + revT := crc32.Table{} + for i, v := range *t { + revI := reverse8[i] + revV := uint32(0) + for j := 0; j < 32; j++ { + if (v & (1 << j)) != 0 { + revV |= 1 << (31 - j) + } + } + revT[revI] = revV + } + *t = revT +} + +var reverse8 = [256]uint8{ + 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, // 0x00 - 0x07 + 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, // 0x08 - 0x0F + 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, // 0x10 - 0x17 + 0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, // 0x18 - 0x1F + 0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, // 0x20 - 0x27 + 0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, // 0x28 - 0x2F + 0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, // 0x30 - 0x37 + 0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, // 0x38 - 0x3F + 0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, // 0x40 - 0x47 + 0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, // 0x48 - 0x4F + 0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, // 0x50 - 0x57 + 0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, // 0x58 - 0x5F + 0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, // 0x60 - 0x67 + 0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, // 0x68 - 0x6F + 0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, // 0x70 - 0x77 + 0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, // 0x78 - 0x7F + 0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, // 0x80 - 0x87 + 0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, // 0x88 - 0x8F + 0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, // 0x90 - 0x97 + 0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, // 0x98 - 0x9F + 0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, // 0xA0 - 0xA7 + 0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, // 0xA8 - 0xAF + 0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, // 0xB0 - 0xB7 + 0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, // 0xB8 - 0xBF + 0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, // 0xC0 - 0xC7 + 0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, // 0xC8 - 0xCF + 0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, // 0xD0 - 0xD7 + 0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, // 0xD8 - 0xDF + 0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, // 0xE0 - 0xE7 + 0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, // 0xE8 - 0xEF + 0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, // 0xF0 - 0xF7 + 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF, // 0xF8 - 0xFF +} diff --git a/std/bzip2/decode_bzip2.wuffs b/std/bzip2/decode_bzip2.wuffs index 550673d5..a3347927 100644 --- a/std/bzip2/decode_bzip2.wuffs +++ b/std/bzip2/decode_bzip2.wuffs @@ -12,10 +12,66 @@ // See the License for the specific language governing permissions and // limitations under the License. +// TODO: optimize. + +pub status "#bad Huffman code (over-subscribed)" +pub status "#bad Huffman code (under-subscribed)" +pub status "#bad block header" +pub status "#bad block length" +pub status "#bad checksum" +pub status "#bad header" +pub status "#bad number of Huffman codes" +pub status "#bad number of sections" +pub status "#unsupported Huffman code" +pub status "#unsupported block randomization" + pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.io_transformer( + bits : base.u32, + n_bits : base.u32[..= 31], + + // Block size is measured prior to the RLE1 step. + block_size : base.u32[..= 900000], + max_incl_block_size : base.u32[..= 900000], + + final_checksum_have : base.u32, + block_checksum_want : base.u32, + original_pointer : base.u32, + num_symbols : base.u32[..= 258], + num_huffman_codes : base.u32[..= 6], + num_sections : base.u32[..= 18001], + code_lengths_bitmask : base.u32, + util : base.utility, +)( + scratch : 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, + + // mtft is the Move To Front Transform state. + mtft : array[256] base.u8, + + // huffman_selectors selects which of the huffman_trees to use for each + // 50-symbol section. + huffman_selectors : array[32768] base.u8, + + // Each array[2] base.u16 is a Huffman tree node. The build_huffman_tree + // method comment details what the base.u16 values mean. + // + // 1024 is just a guess for the worst case number of nodes needed. TODO: be + // more rigorous about deriving this upper bound. + huffman_trees : array[6] array[1024] array[2] base.u16, + + // bwt is the Burrows Wheeler Transform state. Per the README.md file, each + // entry is a row with the low 8 bits holding the L column and the high 20 + // bits holding the Index2 column. The middle 4 bits are unused. + // + // The read_code_lengths and build_huffman_tree methods also re-purpose + // this buffer to temporarily hold up to 258 symbols' code lengths. + bwt : array[1_048576] base.u32, ) pub func decoder.set_quirk_enabled!(quirk: base.u32, enabled: base.bool) { @@ -29,17 +85,757 @@ pub func decoder.workbuf_len() base.range_ii_u64 { } pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) { - // TODO: implement. + var c : base.u8 + var i : base.u32 + var tag : base.u64 + var final_checksum_want : base.u32 + + // Read the header. + c = args.src.read_u8?() + if c <> 0x42 { + return "#bad header" + } + c = args.src.read_u8?() + if c <> 0x5A { + return "#bad header" + } + c = args.src.read_u8?() + if c <> 0x68 { + return "#bad header" + } + c = args.src.read_u8?() + if (c < '1') or ('9' < c) { + return "#bad header" + } + this.max_incl_block_size = ((c - '0') as base.u32) * 100000 while true { - if args.src.length() > 0 { - args.src.skip?(n: args.src.length()) - } - if args.src.is_closed() { + // Read the 48-bit tag. + tag = 0 + i = 0 + while i < 48 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + tag ~mod<<= 1 + tag |= (this.bits >> 31) as base.u64 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + + if tag == 0x1772_4538_5090 { break + } else if tag <> 0x3141_5926_5359 { + return "#bad block header" } - yield? base."$short read" + + this.prepare_block?(src: args.src) + this.execute_block?(src: args.src) + this.invert_bwt!() + this.flush_block?(dst: args.dst) } endwhile - args.dst.write_u8?(a: 0x42) + // Read the 32-bit final checksum. + final_checksum_want = 0 + i = 0 + while i < 32 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + final_checksum_want ~mod<<= 1 + final_checksum_want |= this.bits >> 31 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + if this.final_checksum_have <> final_checksum_want { + return "#bad checksum" + } } + +pri func decoder.prepare_block?(src: base.io_reader) { + var c : base.u8 + var i : base.u32 + var selector : base.u32 + var sel_ff : base.u32 + var movee : base.u8 + var status : base.status + + // Read the 32-bit block checksum. + this.block_checksum_want = 0 + i = 0 + while i < 32 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + this.block_checksum_want ~mod<<= 1 + this.block_checksum_want |= this.bits >> 31 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + + // Read the "block randomized" bit. + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + if (this.bits >> 31) <> 0 { + return "#unsupported block randomization" + } + this.bits ~mod<<= 1 + this.n_bits -= 1 + + // Read the 24-bit original pointer. The BWT technical report calls this I. + this.original_pointer = 0 + i = 0 + while i < 24 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + this.original_pointer ~mod<<= 1 + this.original_pointer |= this.bits >> 31 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + + // Reset the presence bitmap. + i = 0 + while i < 256 { + this.presence[i] = 0 + i += 1 + } endwhile + + // Read the 16-bit high-level presence bitmap. + i = 0 + while i < 256 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + if (this.bits >> 31) <> 0 { + this.presence[i] = 1 + } + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 16 + } endwhile + + // Read the 16-bit low-level presence bitmaps. + this.scratch = 0 + i = 0 + while i < 256 { + if this.presence[i] == 0 { + i += 16 + continue + } + while true { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + this.scratch ~mod+= this.bits >> 31 + this.presence[i & 0xFF] = (this.bits >> 31) as base.u8 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i ~mod+= 1 + if (i & 15) == 0 { + break + } + } endwhile + } endwhile + if (this.scratch < 1) or (256 < this.scratch) { + return "#bad block header" + } + this.num_symbols = this.scratch + 2 + + // Read the 3-bit number of Huffman codes. + this.scratch = 0 + i = 0 + while i < 3 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + this.scratch ~mod<<= 1 + this.scratch |= this.bits >> 31 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + if (this.scratch < 2) or (6 < this.scratch) { + return "#bad block header" + } + this.num_huffman_codes = this.scratch + + // Read the 15-bit number of sections. + this.scratch = 0 + i = 0 + while i < 15 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + this.scratch ~mod<<= 1 + this.scratch |= this.bits >> 31 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + if (this.scratch < 1) or (18001 < this.scratch) { + return "#bad block header" + } + this.num_sections = this.scratch + + // Initialize the MTFT state. + i = 0 + while i < this.num_huffman_codes { + assert i < 6 via "a < b: a < c; c <= b"(c: this.num_huffman_codes) + this.mtft[i] = i as base.u8 + i += 1 + } endwhile + + // Read each section's Huffman code selector, applying the MTFT. + i = 0 + while i < this.num_sections { + assert i < 18001 via "a < b: a < c; c <= b"(c: this.num_sections) + selector = 0 + + // Read a unary encoded natural number. + while true, + inv i < 18001, + { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + if (this.bits >> 31) == 0 { + this.bits ~mod<<= 1 + this.n_bits -= 1 + break + } + this.bits ~mod<<= 1 + this.n_bits -= 1 + selector ~mod+= 1 + if selector >= this.num_huffman_codes { + return "#bad block header" + } + } endwhile + + // Move to front. + if selector == 0 { + this.huffman_selectors[i] = this.mtft[0] + } else { + sel_ff = selector & 0xFF + movee = this.mtft[sel_ff] + this.mtft[1 .. 1 + sel_ff].copy_from_slice!( + s: this.mtft[.. sel_ff]) + this.mtft[0] = movee + this.huffman_selectors[i] = movee + } + + i += 1 + } endwhile + + // Read the Huffman codes. + i = 0 + while i < this.num_huffman_codes { + assert i < 6 via "a < b: a < c; c <= b"(c: this.num_huffman_codes) + this.read_code_lengths?(src: args.src) + status = this.build_huffman_tree!(which: i) + if status.is_error() { + return status + } + i += 1 + } endwhile +} + +pri func decoder.read_code_lengths?(src: base.io_reader) { + var c : base.u8 + var i : base.u32 + var code_length : base.u32 + + this.code_lengths_bitmask = 0 + + // Read the 5-bit starting value. + i = 0 + while i < 5 { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + code_length ~mod<<= 1 + code_length |= this.bits >> 31 + this.bits ~mod<<= 1 + this.n_bits -= 1 + i += 1 + } endwhile + + // Read the code lengths. + i = 0 + while i < this.num_symbols { + assert i < 258 via "a < b: a < c; c <= b"(c: this.num_symbols) + while true, + inv i < 258, + { + if (code_length < 1) or (20 < code_length) { + return "#bad block header" + } + + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + if (this.bits >> 31) == 0 { + this.bits ~mod<<= 1 + this.n_bits -= 1 + break + } + this.bits ~mod<<= 1 + this.n_bits -= 1 + + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + if (this.bits >> 31) == 0 { + code_length ~mod+= 1 + } else { + code_length ~mod-= 1 + } + this.bits ~mod<<= 1 + this.n_bits -= 1 + } endwhile + + this.code_lengths_bitmask |= (1 as base.u32) << (code_length & 31) + this.bwt[i] = code_length + i += 1 + } endwhile +} + +// build_huffman_tree builds a canonical Huffman tree given the symbols' code +// lengths. For the "abraca.txt.bz2" example, the code lengths are: +// - symbol=0x500 (RUNA) cl=3 +// - symbol=0x501 (RUNB) cl=3 +// - symbol=0x401 (m01) cl=2 +// - symbol=0x402 (m02) cl=3 +// - symbol=0x403 (m03) cl=2 +// - symbol=0x7FF (EOB) cl=3 +// +// The bitstring mapping is: +// - "00" 0x401 (m01) +// - "01" 0x403 (m03) +// - "100" 0x500 (RUNA) +// - "101" 0x501 (RUNB) +// - "110" 0x402 (m02) +// - "111" 0x7FF (EOB) +// +// The Huffman tree has 5 nodes. Each node has two children, represented by a +// base.u16 value. 1023 or less means that the child is a branch node. 1024 = +// 0x400 or above means a leaf node (with the symbol values as above). +// - node0 = [0x001 (node1), 0x002 (node2)] +// - node1 = [0x401 (m01) , 0x403 (m03) ] +// - node2 = [0x003 (node3), 0x004 (node4)] +// - node3 = [0x500 (RUNA) , 0x501 (RUNB) ] +// - node4 = [0x402 (m02) , 0x7FF (EOB) ] +// +// For example, the tree walk from node0 right (1) to node2 left (0) to node3 +// left (0) to RUNA means that the RUNA bitstring is "100". +// +// The tree is built incrementally by considering symbols in increasing code +// length order, maintaining a stack of nodes that's the path from the root +// (node0) to the latest created-but-unfinished node. Created means that their +// left child is assigned (non-zero). Unfinished means that their right child +// is pending (zero). For example, after adding the 0x401, 0x403 and 0x500 +// symbols, we would have this (in-progress) tree: +// - node0 = [0x001 (node1), 0x002 (node2)] +// - node1 = [0x401 (m01) , 0x403 (m03) ] +// - node2 = [0x003 (node3), 0 ] +// - node3 = [0x500 (RUNA) , 0 ] +// +// The stack would be [node0, node2, node3]. The next symbol would fill in the +// top of the stack, node3. If that symbol's code length matches the stack +// height (here, 3) then it would pop the stack. Otherwise it would push new +// nodes onto the stack until the stack height matched that code length. +pri func decoder.build_huffman_tree!(which: base.u32[..= 5]) base.status { + var code_length : base.u32 + var symbol_index : base.u32 + var num_nodes : base.u32[..= 1023] + var stack_height : base.u32[..= 21] + var stack_values : array[21] base.u32[..= 1023] + var node_index : base.u32[..= 1023] + var leaf_value : base.u16 + + // Push a root node. + this.huffman_trees[args.which][0][0] = 0 + this.huffman_trees[args.which][0][1] = 0 + num_nodes = 1 + stack_height = 1 + stack_values[0] = 0 + + code_length = 1 + while code_length <= 20 { + if (this.code_lengths_bitmask & ((1 as base.u32) << code_length)) == 0 { + code_length += 1 + continue + } + symbol_index = 0 + while symbol_index < this.num_symbols, + inv code_length <= 20, + { + assert symbol_index < 258 via "a < b: a < c; c <= b"(c: this.num_symbols) + if this.bwt[symbol_index] <> code_length { + symbol_index += 1 + continue + } + + while true, + inv code_length <= 20, + inv symbol_index < 258, + post stack_height > 0, + { + if stack_height <= 0 { + return "#bad Huffman code (over-subscribed)" + } else if stack_height >= code_length { + break + } + assert stack_height < 20 via "a < b: a < c; c <= b"(c: code_length) + + node_index = stack_values[stack_height - 1] + if this.huffman_trees[args.which][node_index][0] == 0 { + this.huffman_trees[args.which][node_index][0] = num_nodes as base.u16 + } else { + this.huffman_trees[args.which][node_index][1] = num_nodes as base.u16 + } + if num_nodes >= 1023 { + return "#unsupported Huffman code" + } + stack_values[stack_height] = num_nodes + this.huffman_trees[args.which][num_nodes][0] = 0 + this.huffman_trees[args.which][num_nodes][1] = 0 + num_nodes += 1 + stack_height += 1 + } endwhile + + node_index = stack_values[stack_height - 1] + if symbol_index < 2 { + leaf_value = (0x500 + symbol_index) as base.u16 + } else if (symbol_index + 1) < this.num_symbols { + leaf_value = (0x3FF + symbol_index) as base.u16 + } else { + leaf_value = 0x7FF + } + + if this.huffman_trees[args.which][node_index][0] == 0 { + this.huffman_trees[args.which][node_index][0] = leaf_value + } else { + this.huffman_trees[args.which][node_index][1] = leaf_value + stack_height -= 1 + while stack_height > 0, + inv code_length <= 20, + inv symbol_index < 258, + { + node_index = stack_values[stack_height - 1] + if this.huffman_trees[args.which][node_index][1] == 0 { + break + } + stack_height -= 1 + } endwhile + } + + symbol_index += 1 + } endwhile + code_length += 1 + } endwhile + + if stack_height <> 0 { + return "#bad Huffman code (under-subscribed)" + } + return ok +} + +pri const CLAMP_TO_5 : array[8] base.u8[..= 5] = [0, 1, 2, 3, 4, 5, 5, 5] + +pri func decoder.execute_block?(src: base.io_reader) { + var which : base.u8[..= 5] + var c : base.u8 + var child : base.u16 + var child_ff : base.u32[..= 255] + var i : base.u32 + var j : base.u32 + var ticks : base.u32[..= 50] + var section : base.u32 + var bs : base.u32[..= 1_048575] // 1_048575 = ((1 << 20) - 1) + var output : base.u32[..= 255] + 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 + + which = CLAMP_TO_5[this.huffman_selectors[0] & 7] + section = 1 + + // Initialize the MTFT state. + i = 0 + j = 0 + while i < 256 { + if this.presence[i] <> 0 { + this.mtft[j & 0xFF] = i as base.u8 + j ~mod+= 1 + } + i += 1 + } endwhile + + // Apply the Huffman trees. + ticks = 50 + while.outer true { + if ticks > 0 { + ticks -= 1 + } else { + ticks = 49 + which = CLAMP_TO_5[this.huffman_selectors[section & 32767] & 7] + section ~mod+= 1 + } + + node_index = 0 + while true { + if this.n_bits <= 0 { + c = args.src.read_u8?() + this.bits = (c as base.u32) << 24 + this.n_bits = 8 + assert this.n_bits > 0 + } + child = this.huffman_trees[which][node_index][this.bits >> 31] + this.bits ~mod<<= 1 + this.n_bits -= 1 + + if child < 1024 { // Branch node. + node_index = child as base.u32 + continue + + } else if child < 1280 { // mNN symbol. + // Move to front. + child_ff = (child & 0xFF) as base.u32 + output = this.mtft[child_ff] as base.u32 + this.mtft[1 .. 1 + child_ff].copy_from_slice!( + s: this.mtft[.. child_ff]) + this.mtft[0] = output as base.u8 + + this.bwt[bs] = output + if bs >= this.max_incl_block_size { + return "#bad block length" + } + assert bs < 900000 via "a < b: a < c; c <= b"(c: this.max_incl_block_size) + bs += 1 + run_shift = 0 + break + + } else if child > 1281 { // EOB symbol. + break.outer + } + + // RUNA or RUNB symbol. + if run_shift >= 23 { + return "#bad block length" + } + run = ((child - 1279) as base.u32) << run_shift + run_shift += 1 + i = bs + j = run + bs + if j > this.max_incl_block_size { + return "#bad block length" + } + assert j <= 900000 via "a <= b: a <= c; c <= b"(c: this.max_incl_block_size) + bs = j + + mtft0 = this.mtft[0] as base.u32 + while i < j, + pre j <= 900000, + { + assert i < 900000 via "a < b: a < c; c <= b"(c: j) + this.bwt[i] = mtft0 + i += 1 + } endwhile + break + } endwhile + } endwhile.outer + + if bs > this.max_incl_block_size { + return "#bad block length" + } + assert bs <= 900000 via "a <= b: a <= c; c <= b"(c: this.max_incl_block_size) + this.block_size = bs +} + +// invert_bwt performs "two passes over the data, and one pass over the +// alphabet", per the BWT technical report. +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 + i += 1 + } endwhile + + // Second data pass, but per the README.md file, calculate the Index2 + // column instead of the T column calculated by SRC-RR-124.pdf. + 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 + this.bwt[counts[letter] & 1_048575] |= i << 12 + counts[letter] ~mod+= 1 + i += 1 + } endwhile +} + +pri func decoder.flush_block?(dst: base.io_writer) { + var i : base.u32[..= 1_048575] + var n : base.u32 + var entry : base.u32 + var repeat_count : base.u32[..= 255] + var block_checksum_have : base.u32 + var prev : base.u8 + var curr : base.u8 + + if this.original_pointer >= this.block_size { + return "#bad block length" + } + assert this.original_pointer < 900000 via "a < b: a < c; c <= b"(c: this.block_size) + i = this.bwt[this.original_pointer] >> 12 + + block_checksum_have = 0xFFFF_FFFF + + n = 0 + while n < this.block_size { + assert n < 900000 via "a < b: a < c; c <= b"(c: this.block_size) + entry = this.bwt[i] + curr = (entry & 0xFF) as base.u8 + i = entry >> 12 + + if repeat_count >= 4 { + repeat_count = curr as base.u32 + while repeat_count > 0, + inv n < 900000, + { + block_checksum_have = + REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ prev] ^ + (block_checksum_have ~mod<< 8) + args.dst.write_u8?(a: prev) + repeat_count -= 1 + } endwhile + repeat_count = 0 + } else if curr <> prev { + repeat_count = 1 + block_checksum_have = + REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ curr] ^ + (block_checksum_have ~mod<< 8) + args.dst.write_u8?(a: curr) + } else { + repeat_count += 1 + block_checksum_have = + REV_CRC32_TABLE[((block_checksum_have >> 24) as base.u8) ^ curr] ^ + (block_checksum_have ~mod<< 8) + args.dst.write_u8?(a: curr) + } + + prev = curr + n += 1 + } endwhile + + block_checksum_have ^= 0xFFFF_FFFF + if block_checksum_have <> this.block_checksum_want { + return "#bad checksum" + } + this.final_checksum_have = block_checksum_have ^ ( + (this.final_checksum_have >> 31) | + (this.final_checksum_have ~mod<< 1)) +} + +// The table below was created by script/print-crc32-magic-numbers.go with the +// -reverse flag set. + +pri const REV_CRC32_TABLE : array[256] base.u32 = [ + 0x0000_0000, 0x04C1_1DB7, 0x0982_3B6E, 0x0D43_26D9, 0x1304_76DC, 0x17C5_6B6B, 0x1A86_4DB2, 0x1E47_5005, + 0x2608_EDB8, 0x22C9_F00F, 0x2F8A_D6D6, 0x2B4B_CB61, 0x350C_9B64, 0x31CD_86D3, 0x3C8E_A00A, 0x384F_BDBD, + 0x4C11_DB70, 0x48D0_C6C7, 0x4593_E01E, 0x4152_FDA9, 0x5F15_ADAC, 0x5BD4_B01B, 0x5697_96C2, 0x5256_8B75, + 0x6A19_36C8, 0x6ED8_2B7F, 0x639B_0DA6, 0x675A_1011, 0x791D_4014, 0x7DDC_5DA3, 0x709F_7B7A, 0x745E_66CD, + 0x9823_B6E0, 0x9CE2_AB57, 0x91A1_8D8E, 0x9560_9039, 0x8B27_C03C, 0x8FE6_DD8B, 0x82A5_FB52, 0x8664_E6E5, + 0xBE2B_5B58, 0xBAEA_46EF, 0xB7A9_6036, 0xB368_7D81, 0xAD2F_2D84, 0xA9EE_3033, 0xA4AD_16EA, 0xA06C_0B5D, + 0xD432_6D90, 0xD0F3_7027, 0xDDB0_56FE, 0xD971_4B49, 0xC736_1B4C, 0xC3F7_06FB, 0xCEB4_2022, 0xCA75_3D95, + 0xF23A_8028, 0xF6FB_9D9F, 0xFBB8_BB46, 0xFF79_A6F1, 0xE13E_F6F4, 0xE5FF_EB43, 0xE8BC_CD9A, 0xEC7D_D02D, + 0x3486_7077, 0x3047_6DC0, 0x3D04_4B19, 0x39C5_56AE, 0x2782_06AB, 0x2343_1B1C, 0x2E00_3DC5, 0x2AC1_2072, + 0x128E_9DCF, 0x164F_8078, 0x1B0C_A6A1, 0x1FCD_BB16, 0x018A_EB13, 0x054B_F6A4, 0x0808_D07D, 0x0CC9_CDCA, + 0x7897_AB07, 0x7C56_B6B0, 0x7115_9069, 0x75D4_8DDE, 0x6B93_DDDB, 0x6F52_C06C, 0x6211_E6B5, 0x66D0_FB02, + 0x5E9F_46BF, 0x5A5E_5B08, 0x571D_7DD1, 0x53DC_6066, 0x4D9B_3063, 0x495A_2DD4, 0x4419_0B0D, 0x40D8_16BA, + 0xACA5_C697, 0xA864_DB20, 0xA527_FDF9, 0xA1E6_E04E, 0xBFA1_B04B, 0xBB60_ADFC, 0xB623_8B25, 0xB2E2_9692, + 0x8AAD_2B2F, 0x8E6C_3698, 0x832F_1041, 0x87EE_0DF6, 0x99A9_5DF3, 0x9D68_4044, 0x902B_669D, 0x94EA_7B2A, + 0xE0B4_1DE7, 0xE475_0050, 0xE936_2689, 0xEDF7_3B3E, 0xF3B0_6B3B, 0xF771_768C, 0xFA32_5055, 0xFEF3_4DE2, + 0xC6BC_F05F, 0xC27D_EDE8, 0xCF3E_CB31, 0xCBFF_D686, 0xD5B8_8683, 0xD179_9B34, 0xDC3A_BDED, 0xD8FB_A05A, + 0x690C_E0EE, 0x6DCD_FD59, 0x608E_DB80, 0x644F_C637, 0x7A08_9632, 0x7EC9_8B85, 0x738A_AD5C, 0x774B_B0EB, + 0x4F04_0D56, 0x4BC5_10E1, 0x4686_3638, 0x4247_2B8F, 0x5C00_7B8A, 0x58C1_663D, 0x5582_40E4, 0x5143_5D53, + 0x251D_3B9E, 0x21DC_2629, 0x2C9F_00F0, 0x285E_1D47, 0x3619_4D42, 0x32D8_50F5, 0x3F9B_762C, 0x3B5A_6B9B, + 0x0315_D626, 0x07D4_CB91, 0x0A97_ED48, 0x0E56_F0FF, 0x1011_A0FA, 0x14D0_BD4D, 0x1993_9B94, 0x1D52_8623, + 0xF12F_560E, 0xF5EE_4BB9, 0xF8AD_6D60, 0xFC6C_70D7, 0xE22B_20D2, 0xE6EA_3D65, 0xEBA9_1BBC, 0xEF68_060B, + 0xD727_BBB6, 0xD3E6_A601, 0xDEA5_80D8, 0xDA64_9D6F, 0xC423_CD6A, 0xC0E2_D0DD, 0xCDA1_F604, 0xC960_EBB3, + 0xBD3E_8D7E, 0xB9FF_90C9, 0xB4BC_B610, 0xB07D_ABA7, 0xAE3A_FBA2, 0xAAFB_E615, 0xA7B8_C0CC, 0xA379_DD7B, + 0x9B36_60C6, 0x9FF7_7D71, 0x92B4_5BA8, 0x9675_461F, 0x8832_161A, 0x8CF3_0BAD, 0x81B0_2D74, 0x8571_30C3, + 0x5D8A_9099, 0x594B_8D2E, 0x5408_ABF7, 0x50C9_B640, 0x4E8E_E645, 0x4A4F_FBF2, 0x470C_DD2B, 0x43CD_C09C, + 0x7B82_7D21, 0x7F43_6096, 0x7200_464F, 0x76C1_5BF8, 0x6886_0BFD, 0x6C47_164A, 0x6104_3093, 0x65C5_2D24, + 0x119B_4BE9, 0x155A_565E, 0x1819_7087, 0x1CD8_6D30, 0x029F_3D35, 0x065E_2082, 0x0B1D_065B, 0x0FDC_1BEC, + 0x3793_A651, 0x3352_BBE6, 0x3E11_9D3F, 0x3AD0_8088, 0x2497_D08D, 0x2056_CD3A, 0x2D15_EBE3, 0x29D4_F654, + 0xC5A9_2679, 0xC168_3BCE, 0xCC2B_1D17, 0xC8EA_00A0, 0xD6AD_50A5, 0xD26C_4D12, 0xDF2F_6BCB, 0xDBEE_767C, + 0xE3A1_CBC1, 0xE760_D676, 0xEA23_F0AF, 0xEEE2_ED18, 0xF0A5_BD1D, 0xF464_A0AA, 0xF927_8673, 0xFDE6_9BC4, + 0x89B8_FD09, 0x8D79_E0BE, 0x803A_C667, 0x84FB_DBD0, 0x9ABC_8BD5, 0x9E7D_9662, 0x933E_B0BB, 0x97FF_AD0C, + 0xAFB0_10B1, 0xAB71_0D06, 0xA632_2BDF, 0xA2F3_3668, 0xBCB4_666D, 0xB875_7BDA, 0xB536_5D03, 0xB1F7_40B4, +] diff --git a/test/c/std/bzip2.c b/test/c/std/bzip2.c index 5c622315..7ef3dba0 100644 --- a/test/c/std/bzip2.c +++ b/test/c/std/bzip2.c @@ -91,7 +91,7 @@ test_wuffs_bzip2_decode_interface() { WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); return do_test__wuffs_base__io_transformer( wuffs_bzip2__decoder__upcast_as__wuffs_base__io_transformer(&dec), - "test/data/romeo.txt.bz2", 0, SIZE_MAX, 1, 0x42); + "test/data/romeo.txt.bz2", 0, SIZE_MAX, 942, 0x0A); } const char* // @@ -125,6 +125,20 @@ wuffs_bzip2_decode(wuffs_base__io_buffer* dst, } } +const char* // +test_wuffs_bzip2_decode_midsummer() { + CHECK_FOCUS(__func__); + return do_test_io_buffers(wuffs_bzip2_decode, &g_bzip2_midsummer_gt, + UINT64_MAX, UINT64_MAX); +} + +const char* // +test_wuffs_bzip2_decode_pi() { + CHECK_FOCUS(__func__); + return do_test_io_buffers(wuffs_bzip2_decode, &g_bzip2_pi_gt, UINT64_MAX, + UINT64_MAX); +} + // ---------------- Mimic Tests #ifdef WUFFS_MIMIC @@ -166,6 +180,8 @@ bench_wuffs_bzip2_decode_100k() { proc g_tests[] = { test_wuffs_bzip2_decode_interface, + test_wuffs_bzip2_decode_midsummer, + test_wuffs_bzip2_decode_pi, #ifdef WUFFS_MIMIC