diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 934cbaa2..65d80924 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -36865,6 +36865,14 @@ wuffs_jpeg__decoder__fill_bitstream( wuffs_jpeg__decoder* self, wuffs_base__io_buffer* a_src); +static wuffs_base__empty_struct +wuffs_jpeg__decoder__load_mcu_blocks_for_single_component( + wuffs_jpeg__decoder* self, + uint32_t a_mx, + uint32_t a_my, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_csel); + static wuffs_base__empty_struct wuffs_jpeg__decoder__load_mcu_blocks( wuffs_jpeg__decoder* self, @@ -39997,6 +40005,39 @@ wuffs_jpeg__decoder__fill_bitstream( return wuffs_base__make_empty_struct(); } +// -------- func jpeg.decoder.load_mcu_blocks_for_single_component + +static wuffs_base__empty_struct +wuffs_jpeg__decoder__load_mcu_blocks_for_single_component( + wuffs_jpeg__decoder* self, + uint32_t a_mx, + uint32_t a_my, + wuffs_base__slice_u8 a_workbuf, + uint32_t a_csel) { + uint64_t v_stride16 = 0; + uint64_t v_offset = 0; + wuffs_base__slice_u8 v_s = {0}; + uint32_t v_i = 0; + + while (true) { + v_stride16 = ((uint64_t)((self->private_impl.f_components_workbuf_widths[a_csel] * 16u))); + v_offset = (self->private_impl.f_components_workbuf_offsets[(a_csel | 4u)] + (((uint64_t)(a_mx)) * 128u) + (((uint64_t)(a_my)) * v_stride16)); + if (v_offset <= ((uint64_t)(a_workbuf.len))) { + v_s = wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset); + if (((uint64_t)(v_s.len)) >= 128u) { + v_i = 0u; + while (v_i < 64u) { + self->private_data.f_mcu_blocks[0u][v_i] = ((uint16_t)(((((uint16_t)(v_s.ptr[((2u * v_i) + 0u)])) << 0u) | (((uint16_t)(v_s.ptr[((2u * v_i) + 1u)])) << 8u)))); + v_i += 1u; + } + } + } + goto label__0__break; + } + label__0__break:; + return wuffs_base__make_empty_struct(); +} + // -------- func jpeg.decoder.load_mcu_blocks static wuffs_base__empty_struct @@ -40167,6 +40208,10 @@ wuffs_jpeg__decoder__apply_progressive_idct( wuffs_jpeg__decoder* self, wuffs_base__slice_u8 a_workbuf) { uint32_t v_csel = 0; + uint32_t v_scan_width_in_mcus = 0; + uint32_t v_scan_height_in_mcus = 0; + uint32_t v_mcu_blocks_mx_mul_0 = 0; + uint32_t v_mcu_blocks_my_mul_0 = 0; uint32_t v_my = 0; uint32_t v_mx = 0; uint64_t v_stride = 0; @@ -40174,16 +40219,21 @@ wuffs_jpeg__decoder__apply_progressive_idct( v_csel = 0u; while (v_csel < self->private_impl.f_num_components) { - self->private_impl.f_scan_num_components = 1u; - self->private_impl.f_scan_comps_cselector[0u] = ((uint8_t)(v_csel)); - wuffs_jpeg__decoder__calculate_single_component_scan_fields(self); + v_scan_width_in_mcus = wuffs_jpeg__decoder__quantize_dimension(self, self->private_impl.f_width, self->private_impl.f_components_h[v_csel], self->private_impl.f_max_incl_components_h); + v_scan_height_in_mcus = wuffs_jpeg__decoder__quantize_dimension(self, self->private_impl.f_height, self->private_impl.f_components_v[v_csel], self->private_impl.f_max_incl_components_v); + v_mcu_blocks_mx_mul_0 = 8u; + v_mcu_blocks_my_mul_0 = (8u * self->private_impl.f_components_workbuf_widths[v_csel]); v_my = 0u; - while (v_my < self->private_impl.f_scan_height_in_mcus) { + while (v_my < v_scan_height_in_mcus) { v_mx = 0u; - while (v_mx < self->private_impl.f_scan_width_in_mcus) { - wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf); + while (v_mx < v_scan_width_in_mcus) { + wuffs_jpeg__decoder__load_mcu_blocks_for_single_component(self, + v_mx, + v_my, + a_workbuf, + v_csel); v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel])); - v_offset = (self->private_impl.f_mcu_blocks_offset[0u] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[0u])) * ((uint64_t)(v_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[0u])) * ((uint64_t)(v_my)))); + v_offset = (self->private_impl.f_components_workbuf_offsets[v_csel] + (((uint64_t)(v_mcu_blocks_mx_mul_0)) * ((uint64_t)(v_mx))) + (((uint64_t)(v_mcu_blocks_my_mul_0)) * ((uint64_t)(v_my)))); if (v_offset <= ((uint64_t)(a_workbuf.len))) { wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs index e3d217b5..71135835 100644 --- a/std/jpeg/decode_jpeg.wuffs +++ b/std/jpeg/decode_jpeg.wuffs @@ -1544,6 +1544,36 @@ pri func decoder.fill_bitstream!(src: base.io_reader) { this.bitstream_wi = wi } +pri func decoder.load_mcu_blocks_for_single_component!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2000], workbuf: slice base.u8, csel: base.u32[..= 3]) { + var stride16 : base.u64[..= 0x10_0080] + var offset : base.u64 + var s : slice base.u8 + var i : base.u32 + + // "while true" is redundant but minimizes the diff with load_mcu_blocks. + while true { + stride16 = (this.components_workbuf_widths[args.csel] * 16) as base.u64 + offset = this.components_workbuf_offsets[args.csel | 4] + + ((args.mx as base.u64) * 128) + + ((args.my as base.u64) * stride16) + if offset <= args.workbuf.length() { + s = args.workbuf[offset ..] + if s.length() >= 128 { + i = 0 + while i < 64, + inv s.length() >= 128, + { + this.mcu_blocks[0][i] = ( + ((s[(2 * i) + 0] as base.u16) << 0) | + ((s[(2 * i) + 1] as base.u16) << 8)) as base.u16 + i += 1 + } endwhile + } + } + break + } endwhile +} + pri func decoder.load_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2000], workbuf: slice base.u8) { var b : base.u32 var csel : base.u8[..= 3] @@ -1678,6 +1708,11 @@ pri func decoder.skip_past_the_next_restart_marker?(src: base.io_reader) { pri func decoder.apply_progressive_idct!(workbuf: slice base.u8) { var csel : base.u32 + var scan_width_in_mcus : base.u32[..= 0x2000] + var scan_height_in_mcus : base.u32[..= 0x2000] + var mcu_blocks_mx_mul_0 : base.u32[..= 0x00_0020] + var mcu_blocks_my_mul_0 : base.u32[..= 0x20_0100] + var my : base.u32 var mx : base.u32 @@ -1688,28 +1723,32 @@ pri func decoder.apply_progressive_idct!(workbuf: slice base.u8) { while csel < this.num_components { assert csel < 4 via "a < b: a < c; c <= b"(c: this.num_components) - // Fake a single-component scan for load_mcu_blocks and decode_idct. - this.scan_num_components = 1 - this.scan_comps_cselector[0] = csel as base.u8 - this.calculate_single_component_scan_fields!() + // Fake a single-component scan. + scan_width_in_mcus = this.quantize_dimension( + width: this.width, h: this.components_h[csel], max_incl_h: this.max_incl_components_h) + scan_height_in_mcus = this.quantize_dimension( + width: this.height, h: this.components_v[csel], max_incl_h: this.max_incl_components_v) + mcu_blocks_mx_mul_0 = 8 + mcu_blocks_my_mul_0 = 8 * this.components_workbuf_widths[csel] + // Apply IDCT to the MCU blocks in the csel'th component. my = 0 - while my < this.scan_height_in_mcus, + while my < scan_height_in_mcus, inv csel < 4, { - assert my < 0x2000 via "a < b: a < c; c <= b"(c: this.scan_height_in_mcus) + assert my < 0x2000 via "a < b: a < c; c <= b"(c: scan_height_in_mcus) mx = 0 - while mx < this.scan_width_in_mcus, + while mx < scan_width_in_mcus, inv csel < 4, inv my < 0x2000, { - assert mx < 0x2000 via "a < b: a < c; c <= b"(c: this.scan_width_in_mcus) - this.load_mcu_blocks!(mx: mx, my: my, workbuf: args.workbuf) + assert mx < 0x2000 via "a < b: a < c; c <= b"(c: scan_width_in_mcus) + this.load_mcu_blocks_for_single_component!(mx: mx, my: my, workbuf: args.workbuf, csel: csel) stride = this.components_workbuf_widths[csel] as base.u64 - offset = this.mcu_blocks_offset[0] + - ((this.mcu_blocks_mx_mul[0] as base.u64) * (mx as base.u64)) + - ((this.mcu_blocks_my_mul[0] as base.u64) * (my as base.u64)) + offset = this.components_workbuf_offsets[csel] + + ((mcu_blocks_mx_mul_0 as base.u64) * (mx as base.u64)) + + ((mcu_blocks_my_mul_0 as base.u64) * (my as base.u64)) if offset <= args.workbuf.length() { this.decode_idct!( dst_buffer: args.workbuf[offset ..],