| // Copyright 2023 The Wuffs Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // https://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or https://opensource.org/licenses/MIT>, 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 |
| |
| pri func decoder.decode_mcu_progressive_ac_high_bits!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { |
| var ret : base.u32 |
| |
| var bits : base.u64 |
| var n_bits : base.u32 |
| |
| var r : base.io_reader |
| var pos : base.u32 |
| |
| var ac_huff_table_fast : nptr roarray[256] base.u16 |
| |
| var ac_h : base.u8[..= 7] |
| var ac_symbol : base.u32[..= 0xFF] |
| var ac_ht_fast : base.u32 |
| var ac_bl : base.u32 |
| var ac_code : base.u32 |
| var ac_blm1 : base.u32[..= 15] |
| var ac_ht_slow : base.u32 |
| var ac_value : base.u16 |
| var ac_extend : base.u16 |
| |
| var ac_rrrr : base.u32[..= 15] |
| var ac_ssss : base.u32[..= 15] |
| |
| var z : base.u32[..= 79] // 79 = 63 + 15 + 1. |
| |
| if this.eob_run > 0 { |
| this.eob_run -= 1 |
| return 0 |
| } |
| |
| bits = this.bitstream_bits |
| n_bits = this.bitstream_n_bits |
| |
| if this.bitstream_ri > this.bitstream_wi { |
| return 2 // Internal error. |
| } |
| io_bind (io: r, data: this.bitstream_buffer[this.bitstream_ri .. this.bitstream_wi], history_position: this.bitstream_ri as base.u64) { |
| while.goto_done true {{ |
| |
| while.block true { |
| // Ensure that we have enough bits for this iteration of the |
| // while.block loop body. Worst case, there are 64 components and |
| // each one needs (16 + 15) bits (round that up to 4 bytes), so we |
| // need (64 * 4) = 256 bytes available. 8 more bytes of slack means |
| // that we can always call peek_u64be. |
| if r.length() < 264 { |
| ret = 1 // Request another fill_bitstream call. |
| break.goto_done |
| } |
| |
| // Ensure the informal "the lower bound on the number of loaded |
| // bits is at least 16" loop pre-condition below. |
| if n_bits < 16 { |
| bits |= r.peek_u64be() >> (n_bits & 63) |
| // Skip these lines that are normally part of "load more bits". |
| // It's unnecessary, just for the informal (NB > 16) below, and |
| // skipping it avoids a small but negative performance impact. |
| // |
| // r.skip_u32_fast!( etc ) |
| // n_bits |= 56 |
| } |
| |
| z = this.mcu_zig_index |
| this.mcu_zig_index = 0 |
| ac_h = this.mcu_blocks_ac_hselector[0] |
| ac_huff_table_fast = this.huff_tables_fast[ac_h][..] as ptr array[256] base.u16 |
| while.ac_components z <= (this.scan_se as base.u32), |
| inv ac_huff_table_fast <> nullptr, |
| { |
| assert z < 64 via "a < b: a <= c; c < b"(c: (this.scan_se as base.u32)) |
| |
| // Use the high bits of the bits variable to look up the |
| // Huffman table. Conceptually, we should do this *after* |
| // "Load at least 56 bits" below (at "LOOK-UP" further below), |
| // but it is noticably faster to do it beforehand: |
| // https://github.com/google/wuffs/commit/d9c7740ea6c4a450401c393787838436895b87bb |
| // |
| // Earlier look-up is OK because there is a informal loop |
| // pre-condition (informal means not enforced by the Wuffs |
| // compiler) that (NB >= 16) here, where NB is "the number of |
| // loaded bits in the bits variable". It is literally n_bits |
| // for almost all loop iterations, but it can be higher on the |
| // first iteration, set up by "Ensure the informal" above. |
| // |
| // For subsequent iterations, the "Load at least 56 bits" below |
| // does what it says. The Huffman code consumes up to 16 bits |
| // and processing the Huffman symbol's ssss nibble consumes up |
| // to 15 bits. (56 - 16 - 15) = 25 >= 16 so at the end of the |
| // loop body, (n_bits >= 16). |
| // |
| // This 16 bound has some slack, as (NB >= 8) is all we need |
| // when ac_huff_table_fast has (1 << 8) entries, but a bound of |
| // 16 (the longest JPEG Huffman code bit length) won't need to |
| // change even if, in the future, the look-up table size grows. |
| ac_ht_fast = ac_huff_table_fast[bits >> 56] as base.u32 |
| |
| // Load at least 56 bits. |
| // |
| // TODO: eliminate this bounds check entirely. |
| if r.length() < 8 { |
| ret = 2 // Internal error. |
| break.goto_done |
| } |
| bits |= r.peek_u64be() >> (n_bits & 63) |
| r.skip_u32_fast!(actual: (63 - (n_bits & 63)) >> 3, worst_case: 8) |
| n_bits |= 56 |
| |
| // Read the Huffman-encoded ac_symbol, up to 16 bits long. |
| // |
| // LOOK-UP: "ac_ht_fast = etc" conceptually happens here, just |
| // before deriving ac_bl from ac_ht_fast. |
| ac_bl = ac_ht_fast >> 8 |
| if n_bits >= ac_bl { |
| ac_symbol = 0xFF & ac_ht_fast |
| bits ~mod<<= (ac_bl & 63) |
| n_bits -= ac_bl |
| } else { |
| ac_code = (bits >> 55) as base.u32 |
| ac_blm1 = 8 |
| bits ~mod<<= 9 |
| n_bits ~mod-= 9 |
| while true, |
| inv ac_huff_table_fast <> nullptr, |
| inv z < 64, |
| { |
| ac_ht_slow = this.huff_tables_slow[ac_h][ac_blm1] |
| if ac_code < (ac_ht_slow >> 8) { |
| ac_symbol = this.huff_tables_symbols[ac_h][0xFF & (ac_code ~mod+ ac_ht_slow)] as base.u32 |
| break |
| } |
| ac_code = (ac_code ~mod<< 1) | ((bits >> 63) as base.u32) |
| bits ~mod<<= 1 |
| n_bits ~mod-= 1 |
| ac_blm1 = (ac_blm1 + 1) & 15 |
| if ac_blm1 == 0 { |
| ac_symbol = 0 |
| break |
| } |
| } endwhile |
| } |
| |
| // Split the 8-bit ac_symbol into two 4-bit halves, per section |
| // F.2.2.2 "Decoding procedure for AC coefficients". |
| ac_rrrr = ac_symbol >> 4 |
| z += ac_rrrr + 1 |
| ac_ssss = ac_symbol & 15 |
| ac_extend = EXTEND[ac_ssss] |
| |
| // Process the ac_value in the next ac_ssss (up to 15) bits or |
| // the eob_run in the next ac_rrrr (up to 15) bits. |
| if ac_ssss > 0 { |
| ac_value = ((bits >> (64 - ac_ssss)) & 0xFFFF) as base.u16 |
| ac_value ~mod+= ac_extend & |
| (((this.util.sign_extend_rshift_u64(a: bits, n: 63) & 0xFFFF) as base.u16) ^ 0xFFFF) |
| bits ~mod<<= ac_ssss |
| n_bits ~mod-= ac_ssss |
| this.mcu_blocks[0][UNZIG[z]] = |
| ((ac_value ~mod<< this.scan_al) & 0xFFFF) as base.u16 |
| } else if ac_rrrr < 15 { |
| this.eob_run = (((1 as base.u16) << ac_rrrr) - 1) as base.u16 |
| if ac_rrrr > 0 { |
| this.eob_run ~mod+= ((bits >> (64 - ac_rrrr)) & 0xFFFF) as base.u16 |
| bits ~mod<<= ac_rrrr |
| n_bits ~mod-= ac_rrrr |
| } |
| break.ac_components |
| } |
| } endwhile.ac_components |
| |
| break.block |
| } endwhile.block |
| |
| break.goto_done |
| }} endwhile.goto_done |
| |
| pos = (r.position() & 0xFFFF_FFFF) as base.u32 |
| if pos > this.bitstream_wi { |
| ret = 2 // Internal error. |
| } else { |
| assert pos <= 0x800 via "a <= b: a <= c; c <= b"(c: this.bitstream_wi) |
| this.bitstream_ri = pos |
| } |
| } |
| |
| this.bitstream_bits = bits |
| this.bitstream_n_bits = n_bits |
| return ret |
| } |