From 9ef114be4344e2c0e9ffd005110eeb56782d3937 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Fri, 9 Feb 2024 22:07:38 +1100 Subject: [PATCH] std/xz: prepare to add BCJ filters --- release/c/wuffs-unsupported-snapshot.c | 172 ++++++++++++++---- std/xz/decode_filter.wuffs | 11 +- std/xz/decode_xz.wuffs | 53 +++++- test/data/artificial-xz-filter/make.go | 79 ++++++++ .../xz-filter-07-9a3fb8ae-arm.dat | Bin 0 -> 256 bytes .../xz-filter-07-9a3fb8ae-arm.dat.xz | Bin 0 -> 316 bytes test/mzcat-checksums-of-data.txt | 1 + 7 files changed, 275 insertions(+), 41 deletions(-) create mode 100644 test/data/artificial-xz-filter/make.go create mode 100644 test/data/artificial-xz-filter/xz-filter-07-9a3fb8ae-arm.dat create mode 100644 test/data/artificial-xz-filter/xz-filter-07-9a3fb8ae-arm.dat.xz diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index c9139a1d..d0060521 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -13799,6 +13799,7 @@ extern const char wuffs_xz__error__bad_padding[]; extern const char wuffs_xz__error__truncated_input[]; extern const char wuffs_xz__error__unsupported_checksum_algorithm[]; extern const char wuffs_xz__error__unsupported_filter[]; +extern const char wuffs_xz__error__unsupported_filter_combination[]; // ---------------- Public Consts @@ -13920,11 +13921,15 @@ struct wuffs_xz__decoder__struct { uint32_t f_num_non_final_filters; uint32_t f_checksummer; bool f_ignore_checksum; + uint8_t f_bcj_undo_index; bool f_block_has_compressed_size; bool f_block_has_uncompressed_size; uint64_t f_block_compressed_size; uint64_t f_block_uncompressed_size; + uint8_t (*choosy_apply_non_final_filters)( + wuffs_xz__decoder* self, + wuffs_base__slice_u8 a_dst_slice); uint32_t p_transform_io; uint32_t p_do_transform_io; uint32_t p_decode_block_header_with_padding; @@ -66747,6 +66752,8 @@ const char wuffs_xz__error__bad_padding[] = "#xz: bad padding"; const char wuffs_xz__error__truncated_input[] = "#xz: truncated input"; const char wuffs_xz__error__unsupported_checksum_algorithm[] = "#xz: unsupported checksum algorithm"; const char wuffs_xz__error__unsupported_filter[] = "#xz: unsupported filter"; +const char wuffs_xz__error__unsupported_filter_combination[] = "#xz: unsupported filter combination"; +const char wuffs_xz__error__internal_error_inconsistent_bcj_filter_state[] = "#xz: internal error: inconsistent BCJ filter state"; // ---------------- Private Consts @@ -66760,11 +66767,23 @@ WUFFS_XZ__CHECKSUM_LENGTH[4] WUFFS_BASE__POTENTIALLY_UNUSED = { // ---------------- Private Function Prototypes WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__empty_struct +static uint8_t wuffs_xz__decoder__apply_non_final_filters( wuffs_xz__decoder* self, wuffs_base__slice_u8 a_dst_slice); +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_xz__decoder__apply_non_final_filters__choosy_default( + wuffs_xz__decoder* self, + wuffs_base__slice_u8 a_dst_slice); + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_xz__decoder__apply_filter_07_arm( + wuffs_xz__decoder* self, + wuffs_base__slice_u8 a_dst_slice); + WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_xz__decoder__do_transform_io( @@ -66843,6 +66862,8 @@ wuffs_xz__decoder__initialize( } } + self->private_impl.choosy_apply_non_final_filters = &wuffs_xz__decoder__apply_non_final_filters__choosy_default; + { wuffs_base__status z = wuffs_crc32__ieee_hasher__initialize( &self->private_data.f_crc32, sizeof(self->private_data.f_crc32), WUFFS_VERSION, options); @@ -66904,10 +66925,18 @@ sizeof__wuffs_xz__decoder(void) { // -------- func xz.decoder.apply_non_final_filters WUFFS_BASE__GENERATED_C_CODE -static wuffs_base__empty_struct +static uint8_t wuffs_xz__decoder__apply_non_final_filters( wuffs_xz__decoder* self, wuffs_base__slice_u8 a_dst_slice) { + return (*self->private_impl.choosy_apply_non_final_filters)(self, a_dst_slice); +} + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_xz__decoder__apply_non_final_filters__choosy_default( + wuffs_xz__decoder* self, + wuffs_base__slice_u8 a_dst_slice) { uint32_t v_f = 0; uint64_t v_i = 0; uint32_t v_filter_id = 0; @@ -66916,7 +66945,7 @@ wuffs_xz__decoder__apply_non_final_filters( uint8_t v_c8 = 0; if (self->private_impl.f_num_non_final_filters <= 0u) { - return wuffs_base__make_empty_struct(); + return 0u; } v_f = (self->private_impl.f_num_non_final_filters - 1u); while (true) { @@ -66948,7 +66977,17 @@ wuffs_xz__decoder__apply_non_final_filters( } v_f -= 1u; } - return wuffs_base__make_empty_struct(); + return 0u; +} + +// -------- func xz.decoder.apply_filter_07_arm + +WUFFS_BASE__GENERATED_C_CODE +static uint8_t +wuffs_xz__decoder__apply_filter_07_arm( + wuffs_xz__decoder* self, + wuffs_base__slice_u8 a_dst_slice) { + return 0u; } // -------- func xz.decoder.get_quirk @@ -67112,6 +67151,7 @@ wuffs_xz__decoder__do_transform_io( uint64_t v_magic = 0; uint64_t v_dmark = 0; uint64_t v_smark = 0; + uint8_t v_i8 = 0; wuffs_base__status v_status = wuffs_base__make_status(NULL); uint32_t v_checksum32_have = 0; uint32_t v_checksum32_want = 0; @@ -67319,6 +67359,11 @@ wuffs_xz__decoder__do_transform_io( v_compressed_size = 0u; v_uncompressed_size = 0u; while (true) { + if (((uint64_t)(self->private_impl.f_bcj_undo_index)) > ((uint64_t)(io2_a_dst - iop_a_dst))) { + status = wuffs_base__make_status(wuffs_base__suspension__short_write); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9); + continue; + } v_dmark = ((uint64_t)(iop_a_dst - io0_a_dst)); v_smark = ((uint64_t)(iop_a_src - io0_a_src)); if (self->private_impl.f_num_non_final_filters == 0u) { @@ -67339,6 +67384,10 @@ wuffs_xz__decoder__do_transform_io( } } } else { + if (self->private_impl.f_bcj_undo_index > 0u) { + wuffs_private_impl__io_writer__copy_from_slice(&iop_a_dst, io2_a_dst,wuffs_base__make_slice_u8(self->private_data.f_filter_data[0u], self->private_impl.f_bcj_undo_index)); + self->private_impl.f_bcj_undo_index = 0u; + } { uint8_t* o_0_io0_a_dst = io0_a_dst; uint8_t* o_0_io1_a_dst = io1_a_dst; @@ -67377,7 +67426,29 @@ wuffs_xz__decoder__do_transform_io( io1_a_dst = o_0_io1_a_dst; } } - wuffs_xz__decoder__apply_non_final_filters(self, wuffs_private_impl__io__since(v_dmark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst)); + self->private_impl.f_bcj_undo_index = wuffs_xz__decoder__apply_non_final_filters(self, wuffs_private_impl__io__since(v_dmark, ((uint64_t)(iop_a_dst - io0_a_dst)), io0_a_dst)); + if ((self->private_impl.f_bcj_undo_index > 0u) && ! wuffs_base__status__is_ok(&v_status)) { + v_i8 = ((uint8_t)(self->private_impl.f_bcj_undo_index - 1u)); + while (true) { + if ( ! (iop_a_dst > io1_a_dst)) { + status = wuffs_base__make_status(wuffs_xz__error__internal_error_inconsistent_bcj_filter_state); + goto exit; + } + self->private_data.f_filter_data[0u][v_i8] = iop_a_dst[-1]; + iop_a_dst--; + if (v_i8 <= 0u) { + break; + } +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_i8 -= 1u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } + } } v_compressed_size += wuffs_private_impl__io__count_since(v_smark, ((uint64_t)(iop_a_src - io0_a_src))); v_uncompressed_size += wuffs_private_impl__io__count_since(v_dmark, ((uint64_t)(iop_a_dst - io0_a_dst))); @@ -67393,7 +67464,7 @@ wuffs_xz__decoder__do_transform_io( break; } status = v_status; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); } if ((self->private_impl.f_block_has_compressed_size && (self->private_impl.f_block_compressed_size != v_compressed_size)) || (self->private_impl.f_block_has_uncompressed_size && (self->private_impl.f_block_uncompressed_size != v_uncompressed_size))) { status = wuffs_base__make_status(wuffs_xz__error__bad_block_header); @@ -67401,7 +67472,7 @@ wuffs_xz__decoder__do_transform_io( } while ((v_compressed_size & 3u) != 0u) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); goto suspend; @@ -67417,7 +67488,7 @@ wuffs_xz__decoder__do_transform_io( } if (self->private_impl.f_ignore_checksum) { self->private_data.s_do_transform_io.scratch = ((uint32_t)(WUFFS_XZ__CHECKSUM_LENGTH[self->private_impl.f_checksummer])); - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); if (self->private_data.s_do_transform_io.scratch > ((uint64_t)(io2_a_src - iop_a_src))) { self->private_data.s_do_transform_io.scratch -= ((uint64_t)(io2_a_src - iop_a_src)); iop_a_src = io2_a_src; @@ -67427,14 +67498,14 @@ wuffs_xz__decoder__do_transform_io( iop_a_src += self->private_data.s_do_transform_io.scratch; } else if (self->private_impl.f_checksummer == 1u) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); uint32_t t_7; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { t_7 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_do_transform_io.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); @@ -67462,14 +67533,14 @@ wuffs_xz__decoder__do_transform_io( } } else if (self->private_impl.f_checksummer == 2u) { { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); uint64_t t_8; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { t_8 = wuffs_base__peek_u64le__no_bounds_check(iop_a_src); iop_a_src += 8; } else { self->private_data.s_do_transform_io.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); @@ -67498,14 +67569,14 @@ wuffs_xz__decoder__do_transform_io( } else if (self->private_impl.f_checksummer == 3u) { v_checksum256_have = wuffs_sha256__hasher__checksum_bitvec256(&self->private_data.f_sha256); { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(17); uint64_t t_9; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { t_9 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); iop_a_src += 8; } else { self->private_data.s_do_transform_io.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(17); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(18); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); @@ -67531,14 +67602,14 @@ wuffs_xz__decoder__do_transform_io( goto exit; } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(18); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(19); uint64_t t_10; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { t_10 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); iop_a_src += 8; } else { self->private_data.s_do_transform_io.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(19); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(20); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); @@ -67564,14 +67635,14 @@ wuffs_xz__decoder__do_transform_io( goto exit; } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(20); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(21); uint64_t t_11; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { t_11 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); iop_a_src += 8; } else { self->private_data.s_do_transform_io.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(21); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(22); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); @@ -67597,14 +67668,14 @@ wuffs_xz__decoder__do_transform_io( goto exit; } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(22); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(23); uint64_t t_12; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { t_12 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); iop_a_src += 8; } else { self->private_data.s_do_transform_io.scratch = 0; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(23); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(24); while (true) { if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { status = wuffs_base__make_status(wuffs_base__suspension__short_read); @@ -67870,6 +67941,8 @@ wuffs_xz__decoder__decode_block_header_sans_padding( break; } } + self->private_impl.choosy_apply_non_final_filters = ( + &wuffs_xz__decoder__apply_non_final_filters__choosy_default); v_f = 0u; while (v_f < self->private_impl.f_num_non_final_filters) { { @@ -67913,35 +67986,47 @@ wuffs_xz__decoder__decode_block_header_sans_padding( self->private_data.f_filter_data[v_f][v_k] = 0u; v_k += 1u; } - } else { + } else if ((v_filter_id < 3u) || (10u < v_filter_id)) { status = wuffs_base__make_status(wuffs_xz__error__unsupported_filter); goto exit; + } else if (v_f != 0u) { + status = wuffs_base__make_status(wuffs_xz__error__unsupported_filter_combination); + goto exit; + } else { + self->private_impl.f_filters[v_f] = ((uint32_t)(v_filter_id)); + if (v_filter_id == 7u) { + self->private_impl.choosy_apply_non_final_filters = ( + &wuffs_xz__decoder__apply_filter_07_arm); + } else { + status = wuffs_base__make_status(wuffs_xz__error__unsupported_filter); + goto exit; + } + { + 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_c8 = t_6; + } + if (v_c8 != 0u) { + status = wuffs_base__make_status(wuffs_xz__error__unsupported_filter); + goto exit; + } } v_f += 1u; } { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + 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_6 = *iop_a_src++; - v_filter_id = t_6; + uint8_t t_7 = *iop_a_src++; + v_filter_id = t_7; } if (v_filter_id == 33u) { - { - 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_c8 = t_7; - } - if (v_c8 != 1u) { - status = wuffs_base__make_status(wuffs_xz__error__bad_filter); - goto exit; - } { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { @@ -67951,6 +68036,19 @@ wuffs_xz__decoder__decode_block_header_sans_padding( uint8_t t_8 = *iop_a_src++; v_c8 = t_8; } + if (v_c8 != 1u) { + status = wuffs_base__make_status(wuffs_xz__error__bad_filter); + goto exit; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); + 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_9 = *iop_a_src++; + v_c8 = t_9; + } v_status = wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1348001792u, (2u | (((uint64_t)(v_c8)) << 8u))); if ( ! wuffs_base__status__is_ok(&v_status)) { status = wuffs_base__make_status(wuffs_xz__error__bad_filter); diff --git a/std/xz/decode_filter.wuffs b/std/xz/decode_filter.wuffs index 9898d5ec..1a92d565 100644 --- a/std/xz/decode_filter.wuffs +++ b/std/xz/decode_filter.wuffs @@ -8,7 +8,9 @@ // // SPDX-License-Identifier: Apache-2.0 OR MIT -pri func decoder.apply_non_final_filters!(dst_slice: slice base.u8) { +pri func decoder.apply_non_final_filters!(dst_slice: slice base.u8) base.u8, + choosy, +{ var f : base.u32[..= 2] var i : base.u64 var filter_id : base.u32[..= 0x7F] @@ -17,7 +19,7 @@ pri func decoder.apply_non_final_filters!(dst_slice: slice base.u8) { var c8 : base.u8 if this.num_non_final_filters <= 0 { - return nothing + return 0 } f = this.num_non_final_filters - 1 @@ -45,4 +47,9 @@ pri func decoder.apply_non_final_filters!(dst_slice: slice base.u8) { } f -= 1 } endwhile + return 0 +} + +pri func decoder.apply_filter_07_arm!(dst_slice: slice base.u8) base.u8 { + return 0 } diff --git a/std/xz/decode_xz.wuffs b/std/xz/decode_xz.wuffs index 8263a90d..54744294 100644 --- a/std/xz/decode_xz.wuffs +++ b/std/xz/decode_xz.wuffs @@ -25,6 +25,9 @@ pub status "#bad padding" pub status "#truncated input" pub status "#unsupported checksum algorithm" pub status "#unsupported filter" +pub status "#unsupported filter combination" + +pri status "#internal error: inconsistent BCJ filter state" pub const DECODER_DST_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE : base.u64 = 0 pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0xFFFF_FFFF + 273 @@ -41,6 +44,8 @@ pub struct decoder? implements base.io_transformer( ignore_checksum : base.bool, + bcj_undo_index : base.u8, + block_has_compressed_size : base.bool, block_has_uncompressed_size : base.bool, @@ -97,6 +102,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work var magic : base.u64 var dmark : base.u64 var smark : base.u64 + var i8 : base.u8 var status : base.status var checksum32_have : base.u32 var checksum32_want : base.u32 @@ -174,18 +180,43 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work compressed_size = 0 uncompressed_size = 0 while true { + if (this.bcj_undo_index as base.u64) > args.dst.length() { + yield? base."$short write" + continue + } + dmark = args.dst.mark() smark = args.src.mark() if this.num_non_final_filters == 0 { status =? this.lzma.transform_io?(dst: args.dst, src: args.src, workbuf: args.workbuf) } else { + if this.bcj_undo_index > 0 { + args.dst.copy_from_slice!(s: this.filter_data[0][.. this.bcj_undo_index]) + this.bcj_undo_index = 0 + } + // The non-final filters will modify the args.dst contents so // that its history isn't what this.lzma considers its // (unfiltered) history. io_forget_history (io: args.dst) { status =? this.lzma.transform_io?(dst: args.dst, src: args.src, workbuf: args.workbuf) } - this.apply_non_final_filters!(dst_slice: args.dst.since(mark: dmark)) + + this.bcj_undo_index = this.apply_non_final_filters!(dst_slice: args.dst.since(mark: dmark)) + if (this.bcj_undo_index > 0) and (not status.is_ok()) { + i8 = this.bcj_undo_index - 1 + while true { + if not args.dst.can_undo_byte() { + return "#internal error: inconsistent BCJ filter state" + } + this.filter_data[0][i8] = args.dst.peek_undo_byte() + args.dst.undo_byte!() + if i8 <= 0 { + break + } + i8 -= 1 + } endwhile + } } compressed_size ~mod+= args.src.count_since(mark: smark) uncompressed_size ~mod+= args.dst.count_since(mark: dmark) @@ -353,6 +384,7 @@ pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) { // Configure the non-final filters. + choose apply_non_final_filters = [apply_non_final_filters] f = 0 while f < this.num_non_final_filters { assert f < 3 via "a < b: a < c; c <= b"(c: this.num_non_final_filters) @@ -378,8 +410,25 @@ pri func decoder.decode_block_header_sans_padding?(src: base.io_reader) { k += 1 } endwhile - } else { + } else if (filter_id < 0x03) or (0x0A < filter_id) { return "#unsupported filter" + } else if f <> 0 { + // We only support BCJ (Branch, Call, Jump) filters if they're the + // only filter (other than LZMA2). This simplifies their undo_byte + // interaction with I/O suspension. + return "#unsupported filter combination" + } else { + this.filters[f] = filter_id as base.u32 + if filter_id == 0x07 { + choose apply_non_final_filters = [apply_filter_07_arm] + } else { + return "#unsupported filter" + } + // We only support a zero BCJ offset. + c8 = args.src.read_u8?() + if c8 <> 0x00 { + return "#unsupported filter" + } } f += 1 diff --git a/test/data/artificial-xz-filter/make.go b/test/data/artificial-xz-filter/make.go new file mode 100644 index 00000000..f436d3ff --- /dev/null +++ b/test/data/artificial-xz-filter/make.go @@ -0,0 +1,79 @@ +// Copyright 2024 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +//go:build ignore +// +build ignore + +package main + +// Usage: go run make.go + +import ( + "fmt" + "hash/crc32" + "os" + "os/exec" +) + +func main() { + if err := main1(); err != nil { + os.Stderr.WriteString(err.Error() + "\n") + os.Exit(1) + } +} + +func main1() error { + recipes := []struct { + filterID string + filterName string + generator func() []byte + }{ + {"07", "arm", genArm}, + } + + for _, recipe := range recipes { + contents := recipe.generator() + filename := fmt.Sprintf("xz-filter-%s-%08x-%s.dat", + recipe.filterID, + crc32.ChecksumIEEE(contents), + recipe.filterName) + if err := os.WriteFile(filename, contents, 0644); err != nil { + return err + } + fmt.Printf("Wrote %s\n", filename) + + cmd := exec.Command("xz", "--keep", "--force", "--"+recipe.filterName, "--lzma2", filename) + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + return err + } + fmt.Printf("Wrote %s.xz\n", filename) + } + return nil +} + +// pi's digits are a source of random-looking numbers. len(pi) is 128. +const pi = "3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844" + +// The artificial data generated below is designed to tickle XZ's BCJ (Branch, +// Call, Jump) filters. See xz-embedded's linux/lib/xz/xz_dec_bcj.c for C code +// implementations. + +func genArm() []byte { + b := make([]byte, 256) + for i := range b { + b[i] = byte(i) + if ((i & 3) == 3) && + ((pi[i>>2] & 1) != 0) { + b[i] = 0xEB + } + } + return b +} diff --git a/test/data/artificial-xz-filter/xz-filter-07-9a3fb8ae-arm.dat b/test/data/artificial-xz-filter/xz-filter-07-9a3fb8ae-arm.dat new file mode 100644 index 0000000000000000000000000000000000000000..51e4d4107bebd9ff0692af90e1a4b5a7160f89b6 GIT binary patch literal 256 zcmZQzWO~iQ%Er#Y$@Q9tmycgSQ0TRYsMu=>NvYQ|vU2hYib~2Vs%oz_G__vq=<2;T zFf=kYF*SQ_VQKZ+#@6n&gQL@H7gslT4^OYxKE8hb0f9lmA)#U65s^{RF|l#+35iL` zDXD3%GcvPY=j7()7Zet~E-5W5uc)kgT~k~4x}mY@bxUhodq-zicTaC$|AdK?CQq3< zZTgIvvtG}cJMZ;^g^OMq^Ms@~8MlpuPUlz_}Wcbg-$n=_pm5rT;lj}7PFCV{{pwMe+ zQL)zwl2Wf_WaZ=)6qS_qRn=abXllK-)YW@!U}$9QY-;w}!_w-tudUtdAV;UyF0O9w zF`izpeSH1=0|JABLqfyCBO;@sV`Agt6B3h>>r>NSw`69$&dJTo?<*{NT~bGk8S+g`uex$E`Yz58B&I(X>y_oK&N|2cW;^_jEh&a+**^!m!xYu9hw zymkA|-Fx??9zA+3|Loaol~=D`YrcE;`oqUhpTB(l_TA#wuh+K!{=H`SctS$q?u=J{ d42(0F8kiUujuqA}+ju1XHxmN`0|QHB6aY|1p{4); literal 0 HcmV?d00001 diff --git a/test/mzcat-checksums-of-data.txt b/test/mzcat-checksums-of-data.txt index 7c917cca..f03ba9b6 100644 --- a/test/mzcat-checksums-of-data.txt +++ b/test/mzcat-checksums-of-data.txt @@ -7,6 +7,7 @@ OK. b19df306 test/data/archive.tar.bz2 OK. b19df306 test/data/archive.tar.gz OK. 6ddef9db test/data/artificial-bzip2/abraca.txt.bz2 OK. 6ddef9db test/data/artificial-bzip2/huffman-258.bz2 +BAD 07100884 test/data/artificial-xz-filter/xz-filter-07-9a3fb8ae-arm.dat.xz OK. acef87f1 test/data/enwik5.lzma OK. acef87f1 test/data/enwik5.xz OK. 3db2cdc6 test/data/midsummer.txt.bz2