Implement std/bzip2

This commit is contained in:
Nigel Tao committed 2022-05-16 23:35:32 +10:00
1 parent 787ff21cc7
commit 68b76a8a56
4 files changed
+2010 -50

No files matched your search

+1129 -42
View File
@@ -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;
}
+61
View File
@@ -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
}
+803 -7
View File
@@ -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,
]
+17 -1
View File
@@ -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