std/jpeg/decode_mcu_default.wuffs - external/github.com/google/wuffs - Git at Google

 // Copyright 2023 The Wuffs Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 pri func decoder.decode_mcu!() base.u32 {
     var ret : base.u32

     var bits   : base.u64
     var n_bits : base.u32
     var csel   : base.u8[..= 3]

     var r   : base.io_reader
     var pos : base.u32

     // etc_bl and etc_blm1 are the Huffman code's "bit length" and "bit length
     // minus 1" for the DC (first) and AC (later) components.

     var dc_h       : base.u8[..= 7]
     var dc_symbol  : base.u32[..= 0x0F]
     var dc_ht_fast : base.u32
     var dc_bl      : base.u32
     var dc_code    : base.u32
     var dc_blm1    : base.u32[..= 15]
     var dc_ht_slow : base.u32
     var dc_value   : base.u32

     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.u32

     var ac_rrrr : base.u32[..= 15]
     var ac_ssss : base.u32[..= 15]
     var z       : base.u32[..= 78]  // 78 = 63 + 15.

     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 this.mcu_current_block < this.mcu_num_blocks {
             assert this.mcu_current_block < 10 via "a < b: a < c; c <= b"(c: this.mcu_num_blocks)
             while.dc_component this.mcu_zig_index <= 0,
                     inv this.mcu_current_block < 10,
             {
                 // Load at least 31 bits, by keeping 56 .. 64 loaded.
                 if r.length() < 8 {
                     ret = 1  // Request another fill_bitstream call.
                     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 dc_symbol, up to 16 bits long.
                 dc_h = 0 | this.scan_comps_td[this.mcu_blocks_sselector[this.mcu_current_block]]
                 dc_ht_fast = this.huff_tables_fast[dc_h][bits >> 56] as base.u32
                 dc_bl = dc_ht_fast >> 8
                 if n_bits >= dc_bl {
                     dc_symbol = 0x0F & dc_ht_fast
                     bits ~mod<<= (dc_bl & 63)
                     n_bits -= dc_bl
                 } else {
                     dc_code = (bits >> 55) as base.u32
                     dc_blm1 = 8
                     bits ~mod<<= 9
                     n_bits ~mod-= 9
                     while true,
                             inv this.mcu_current_block < 10,
                     {
                         dc_ht_slow = this.huff_tables_slow[dc_h][dc_blm1]
                         if dc_code < (dc_ht_slow >> 8) {
                             dc_symbol = 0x0F & (this.huff_tables_symbols[dc_h][0xFF & (dc_code ~mod+ dc_ht_slow)] as base.u32)
                             break
                         }
                         dc_code = (dc_code ~mod<< 1) | ((bits >> 63) as base.u32)
                         bits ~mod<<= 1
                         n_bits ~mod-= 1
                         dc_blm1 = (dc_blm1 + 1) & 15
                         if dc_blm1 == 0 {
                             dc_symbol = 0
                             break
                         }
                     } endwhile
                 }

                 // Process the dc_value in the next dc_symbol (up to 15) bits.
                 //
                 // The dc_value is shifted by (64 - dc_symbol) in two steps,
                 // because we want to shift by 64 (not 0) when dc_symbol is 0.
                 dc_value = (((bits >> 32) >> (32 - dc_symbol)) & 0xFFFF_FFFF) as base.u32
                 if (bits >> 63) == 0 {  // EXTEND per section F.2.2.1.
                     dc_value ~mod+= 1 ~mod+ ((0xFFFF_FFFF as base.u32) ~mod<< dc_symbol)
                 }
                 bits ~mod<<= dc_symbol
                 n_bits ~mod-= dc_symbol
                 csel = this.scan_comps_cselector[this.mcu_blocks_sselector[this.mcu_current_block]]
                 this.mcu_previous_dc_values[csel] ~mod+= (dc_value & 0xFFFF) as base.u16
                 this.mcu_blocks[this.mcu_current_block][0] = this.mcu_previous_dc_values[csel]

                 this.mcu_zig_index = 1
                 break.dc_component
             } endwhile.dc_component

             while.ac_components true,
                     inv this.mcu_current_block < 10,
             {
                 // Load at least 31 bits, by keeping 56 .. 64 loaded.
                 if r.length() < 8 {
                     ret = 1  // Request another fill_bitstream call.
                     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.
                 ac_h = 4 | this.scan_comps_ta[this.mcu_blocks_sselector[this.mcu_current_block]]
                 ac_ht_fast = this.huff_tables_fast[ac_h][bits >> 56] as base.u32
                 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 this.mcu_current_block < 10,
                     {
                         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
                 ac_ssss = ac_symbol & 15

                 // Process the ac_value in the next ac_ssss (up to 15) bits.
                 if ac_ssss > 0 {
                     ac_value = ((bits >> (64 - ac_ssss)) & 0xFFFF_FFFF) as base.u32
                     if (bits >> 63) == 0 {  // EXTEND per section F.2.2.1.
                         ac_value ~mod+= 1 ~mod+ ((0xFFFF_FFFF as base.u32) ~mod<< ac_ssss)
                     }
                     bits ~mod<<= ac_ssss
                     n_bits ~mod-= ac_ssss
                     z = this.mcu_zig_index + ac_rrrr
                     this.mcu_blocks[this.mcu_current_block][UNZIG[z]] = (ac_value & 0xFFFF) as base.u16
                     if (z + 1) > 63 {
                         break.ac_components
                     }
                     this.mcu_zig_index = z + 1
                 } else if (ac_rrrr < 15) or ((this.mcu_zig_index + 16) > 63) {
                     break.ac_components
                 } else {
                     this.mcu_zig_index = this.mcu_zig_index + 16
                 }
             } endwhile.ac_components

             this.mcu_zig_index = 0
             assert this.mcu_current_block < 10
             this.mcu_current_block += 1
         } endwhile.block
         this.mcu_current_block = 0

         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
 }
	// Copyright 2023 The Wuffs Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	pri func decoder.decode_mcu!() base.u32 {
	var ret : base.u32

	var bits : base.u64
	var n_bits : base.u32
	var csel : base.u8[..= 3]

	var r : base.io_reader
	var pos : base.u32

	// etc_bl and etc_blm1 are the Huffman code's "bit length" and "bit length
	// minus 1" for the DC (first) and AC (later) components.

	var dc_h : base.u8[..= 7]
	var dc_symbol : base.u32[..= 0x0F]
	var dc_ht_fast : base.u32
	var dc_bl : base.u32
	var dc_code : base.u32
	var dc_blm1 : base.u32[..= 15]
	var dc_ht_slow : base.u32
	var dc_value : base.u32

	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.u32

	var ac_rrrr : base.u32[..= 15]
	var ac_ssss : base.u32[..= 15]
	var z : base.u32[..= 78] // 78 = 63 + 15.

	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 this.mcu_current_block < this.mcu_num_blocks {
	assert this.mcu_current_block < 10 via "a < b: a < c; c <= b"(c: this.mcu_num_blocks)
	while.dc_component this.mcu_zig_index <= 0,
	inv this.mcu_current_block < 10,
	{
	// Load at least 31 bits, by keeping 56 .. 64 loaded.
	if r.length() < 8 {
	ret = 1 // Request another fill_bitstream call.
	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 dc_symbol, up to 16 bits long.
	dc_h = 0 \| this.scan_comps_td[this.mcu_blocks_sselector[this.mcu_current_block]]
	dc_ht_fast = this.huff_tables_fast[dc_h][bits >> 56] as base.u32
	dc_bl = dc_ht_fast >> 8
	if n_bits >= dc_bl {
	dc_symbol = 0x0F & dc_ht_fast
	bits ~mod<<= (dc_bl & 63)
	n_bits -= dc_bl
	} else {
	dc_code = (bits >> 55) as base.u32
	dc_blm1 = 8
	bits ~mod<<= 9
	n_bits ~mod-= 9
	while true,
	inv this.mcu_current_block < 10,
	{
	dc_ht_slow = this.huff_tables_slow[dc_h][dc_blm1]
	if dc_code < (dc_ht_slow >> 8) {
	dc_symbol = 0x0F & (this.huff_tables_symbols[dc_h][0xFF & (dc_code ~mod+ dc_ht_slow)] as base.u32)
	break
	}
	dc_code = (dc_code ~mod<< 1) \| ((bits >> 63) as base.u32)
	bits ~mod<<= 1
	n_bits ~mod-= 1
	dc_blm1 = (dc_blm1 + 1) & 15
	if dc_blm1 == 0 {
	dc_symbol = 0
	break
	}
	} endwhile
	}

	// Process the dc_value in the next dc_symbol (up to 15) bits.
	//
	// The dc_value is shifted by (64 - dc_symbol) in two steps,
	// because we want to shift by 64 (not 0) when dc_symbol is 0.
	dc_value = (((bits >> 32) >> (32 - dc_symbol)) & 0xFFFF_FFFF) as base.u32
	if (bits >> 63) == 0 { // EXTEND per section F.2.2.1.
	dc_value ~mod+= 1 ~mod+ ((0xFFFF_FFFF as base.u32) ~mod<< dc_symbol)
	}
	bits ~mod<<= dc_symbol
	n_bits ~mod-= dc_symbol
	csel = this.scan_comps_cselector[this.mcu_blocks_sselector[this.mcu_current_block]]
	this.mcu_previous_dc_values[csel] ~mod+= (dc_value & 0xFFFF) as base.u16
	this.mcu_blocks[this.mcu_current_block][0] = this.mcu_previous_dc_values[csel]

	this.mcu_zig_index = 1
	break.dc_component
	} endwhile.dc_component

	while.ac_components true,
	inv this.mcu_current_block < 10,
	{
	// Load at least 31 bits, by keeping 56 .. 64 loaded.
	if r.length() < 8 {
	ret = 1 // Request another fill_bitstream call.
	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.
	ac_h = 4 \| this.scan_comps_ta[this.mcu_blocks_sselector[this.mcu_current_block]]
	ac_ht_fast = this.huff_tables_fast[ac_h][bits >> 56] as base.u32
	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 this.mcu_current_block < 10,
	{
	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
	ac_ssss = ac_symbol & 15

	// Process the ac_value in the next ac_ssss (up to 15) bits.
	if ac_ssss > 0 {
	ac_value = ((bits >> (64 - ac_ssss)) & 0xFFFF_FFFF) as base.u32
	if (bits >> 63) == 0 { // EXTEND per section F.2.2.1.
	ac_value ~mod+= 1 ~mod+ ((0xFFFF_FFFF as base.u32) ~mod<< ac_ssss)
	}
	bits ~mod<<= ac_ssss
	n_bits ~mod-= ac_ssss
	z = this.mcu_zig_index + ac_rrrr
	this.mcu_blocks[this.mcu_current_block][UNZIG[z]] = (ac_value & 0xFFFF) as base.u16
	if (z + 1) > 63 {
	break.ac_components
	}
	this.mcu_zig_index = z + 1
	} else if (ac_rrrr < 15) or ((this.mcu_zig_index + 16) > 63) {
	break.ac_components
	} else {
	this.mcu_zig_index = this.mcu_zig_index + 16
	}
	} endwhile.ac_components

	this.mcu_zig_index = 0
	assert this.mcu_current_block < 10
	this.mcu_current_block += 1
	} endwhile.block
	this.mcu_current_block = 0

	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
	}