From c914f66a6c39a0c47edebc36625f082b561a6fa0 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 30 Apr 2023 23:01:04 +1000 Subject: [PATCH] std/jpeg: decode Huffman entropy coded data Updates #42 --- release/c/wuffs-unsupported-snapshot.c | 461 ++++++++++++++++++++++++- std/jpeg/common_consts.wuffs | 7 +- std/jpeg/decode_jpeg.wuffs | 231 ++++++++++++- std/jpeg/decode_mcu_default.wuffs | 214 ++++++++++++ test/c/std/jpeg.c | 147 +++++++- 5 files changed, 1035 insertions(+), 25 deletions(-) create mode 100644 std/jpeg/decode_mcu_default.wuffs diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index b25dc759..03c472ed 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -8746,6 +8746,7 @@ struct wuffs_jpeg__decoder__struct { uint32_t f_height; uint8_t f_call_sequence; uint8_t f_sof_marker; + uint8_t f_next_restart_marker; uint8_t f_max_incl_components_h; uint8_t f_max_incl_components_v; uint32_t f_num_components; @@ -8766,13 +8767,21 @@ struct wuffs_jpeg__decoder__struct { uint32_t f_scan_width_in_mcus; uint32_t f_scan_height_in_mcus; uint32_t f_mcu_num_blocks; + uint32_t f_mcu_current_block; uint8_t f_mcu_blocks_sselector[16]; - uint32_t f_payload_length; + uint32_t f_mcu_zig_index; + uint16_t f_mcu_previous_dc_values[4]; uint16_t f_restart_interval; uint16_t f_saved_restart_interval; + uint16_t f_restarts_remaining; uint64_t f_frame_config_io_position; + uint32_t f_payload_length; bool f_seen_dqt[4]; bool f_seen_dht[8]; + uint64_t f_bitstream_bits; + uint32_t f_bitstream_n_bits; + uint32_t f_bitstream_ri; + uint32_t f_bitstream_wi; uint8_t f_quant_tables[4][64]; uint8_t f_huff_tables_symbols[8][256]; uint32_t f_huff_tables_slow[8][16]; @@ -8791,9 +8800,12 @@ struct wuffs_jpeg__decoder__struct { uint32_t p_decode_dht[1]; uint32_t p_decode_sos[1]; uint32_t p_prepare_scan[1]; + uint32_t p_skip_past_the_next_restart_marker[1]; } private_impl; struct { + uint8_t f_bitstream_buffer[2048]; + uint16_t f_mcu_blocks[10][64]; uint8_t f_dht_temp_counts[16]; uint8_t f_dht_temp_bit_lengths[256]; uint16_t f_dht_temp_bit_strings[256]; @@ -8823,6 +8835,10 @@ struct wuffs_jpeg__decoder__struct { uint32_t v_total_count; uint32_t v_i; } s_decode_dht[1]; + struct { + uint32_t v_my; + uint32_t v_mx; + } s_decode_sos[1]; struct { uint32_t v_i; } s_prepare_scan[1]; @@ -35365,11 +35381,12 @@ const char wuffs_jpeg__error__unsupported_marker[] = "#jpeg: unsupported marker" const char wuffs_jpeg__error__unsupported_precision_12_bits[] = "#jpeg: unsupported precision (12 bits)"; const char wuffs_jpeg__error__unsupported_precision_16_bits[] = "#jpeg: unsupported precision (16 bits)"; const char wuffs_jpeg__error__unsupported_precision[] = "#jpeg: unsupported precision"; +const char wuffs_jpeg__error__internal_error_inconsistent_decoder_state[] = "#jpeg: internal error: inconsistent decoder state"; // ---------------- Private Consts static const uint8_t -WUFFS_JPEG__UNZIG[64] WUFFS_BASE__POTENTIALLY_UNUSED = { +WUFFS_JPEG__UNZIG[80] WUFFS_BASE__POTENTIALLY_UNUSED = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, @@ -35378,6 +35395,8 @@ WUFFS_JPEG__UNZIG[64] WUFFS_BASE__POTENTIALLY_UNUSED = { 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63, 63, }; // ---------------- Private Initializer Prototypes @@ -35443,11 +35462,25 @@ wuffs_jpeg__decoder__prepare_scan( wuffs_jpeg__decoder* self, wuffs_base__io_buffer* a_src); +static wuffs_base__empty_struct +wuffs_jpeg__decoder__fill_bitstream( + wuffs_jpeg__decoder* self, + wuffs_base__io_buffer* a_src); + +static wuffs_base__status +wuffs_jpeg__decoder__skip_past_the_next_restart_marker( + wuffs_jpeg__decoder* self, + wuffs_base__io_buffer* a_src); + static wuffs_base__status wuffs_jpeg__decoder__swizzle( wuffs_jpeg__decoder* self, wuffs_base__pixel_buffer* a_dst); +static uint32_t +wuffs_jpeg__decoder__decode_mcu( + wuffs_jpeg__decoder* self); + // ---------------- VTables const wuffs_base__image_decoder__func_ptrs @@ -37035,7 +37068,7 @@ wuffs_jpeg__decoder__calculate_huff_tables( label__0__break:; v_i = 0; while (v_i < 256) { - self->private_impl.f_huff_tables_fast[a_tc4_th][v_i] = 0; + self->private_impl.f_huff_tables_fast[a_tc4_th][v_i] = 65535; v_i += 1; } v_j = 0; @@ -37076,12 +37109,19 @@ wuffs_jpeg__decoder__decode_sos( wuffs_base__slice_u8 a_workbuf) { wuffs_base__status status = wuffs_base__make_status(NULL); - uint32_t v_restarts = 0; uint32_t v_my = 0; uint32_t v_mx = 0; + uint32_t v_decode_mcu_result = 0; + uint32_t v_bitstream_length = 0; + uint32_t v_i = 0; + uint32_t v_j = 0; wuffs_base__status v_status = wuffs_base__make_status(NULL); uint32_t coro_susp_point = self->private_impl.p_decode_sos[0]; + if (coro_susp_point) { + v_my = self->private_data.s_decode_sos[0].v_my; + v_mx = self->private_data.s_decode_sos[0].v_mx; + } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -37090,14 +37130,76 @@ wuffs_jpeg__decoder__decode_sos( if (status.repr) { goto suspend; } - v_restarts = ((uint32_t)(self->private_impl.f_restart_interval)); + self->private_impl.f_next_restart_marker = 0; + self->private_impl.f_restarts_remaining = self->private_impl.f_restart_interval; + self->private_impl.f_mcu_previous_dc_values[0] = 0; + self->private_impl.f_mcu_previous_dc_values[1] = 0; + self->private_impl.f_mcu_previous_dc_values[2] = 0; + self->private_impl.f_mcu_previous_dc_values[3] = 0; + self->private_impl.f_bitstream_bits = 0; + self->private_impl.f_bitstream_n_bits = 0; + self->private_impl.f_bitstream_ri = 0; + self->private_impl.f_bitstream_wi = 0; + wuffs_jpeg__decoder__fill_bitstream(self, a_src); v_my = 0; while (v_my < self->private_impl.f_scan_height_in_mcus) { v_mx = 0; while (v_mx < self->private_impl.f_scan_width_in_mcus) { - if (v_restarts > 0) { - v_restarts -= 1; - if (v_restarts == 0) { + self->private_impl.f_mcu_current_block = 0; + self->private_impl.f_mcu_zig_index = 0; + while (true) { + v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self); + if (v_decode_mcu_result == 0) { + goto label__decode_mcu__break; + } else if (v_decode_mcu_result != 1) { + status = wuffs_base__make_status(wuffs_jpeg__error__internal_error_inconsistent_decoder_state); + goto exit; + } + while (true) { + v_bitstream_length = ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri)); + wuffs_jpeg__decoder__fill_bitstream(self, a_src); + if (v_bitstream_length < ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri))) { + goto label__fill_bitstream__break; + } + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); + } + label__fill_bitstream__break:; + } + label__decode_mcu__break:; + v_i = 0; + v_j = 0; + while (v_i < self->private_impl.f_mcu_num_blocks) { + while (v_j < 64) { + self->private_data.f_mcu_blocks[v_i][v_j] = 0; + v_j += 1; + } + v_i += 1; + } + if (self->private_impl.f_restarts_remaining > 0) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + self->private_impl.f_restarts_remaining -= 1; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + if (self->private_impl.f_restarts_remaining == 0) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + status = wuffs_jpeg__decoder__skip_past_the_next_restart_marker(self, a_src); + if (status.repr) { + goto suspend; + } + self->private_impl.f_restarts_remaining = self->private_impl.f_restart_interval; + self->private_impl.f_mcu_previous_dc_values[0] = 0; + self->private_impl.f_mcu_previous_dc_values[1] = 0; + self->private_impl.f_mcu_previous_dc_values[2] = 0; + self->private_impl.f_mcu_previous_dc_values[3] = 0; + self->private_impl.f_bitstream_bits = 0; + self->private_impl.f_bitstream_n_bits = 0; + self->private_impl.f_bitstream_ri = 0; + self->private_impl.f_bitstream_wi = 0; } } v_mx += 1; @@ -37122,6 +37224,8 @@ wuffs_jpeg__decoder__decode_sos( goto suspend; suspend: self->private_impl.p_decode_sos[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_decode_sos[0].v_my = v_my; + self->private_data.s_decode_sos[0].v_mx = v_mx; goto exit; exit: @@ -37350,6 +37454,155 @@ wuffs_jpeg__decoder__prepare_scan( return status; } +// -------- func jpeg.decoder.fill_bitstream + +static wuffs_base__empty_struct +wuffs_jpeg__decoder__fill_bitstream( + wuffs_jpeg__decoder* self, + wuffs_base__io_buffer* a_src) { + uint32_t v_i = 0; + uint32_t v_wi = 0; + uint8_t v_c = 0; + uint32_t v_n = 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 && a_src->data.ptr) { + 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; + } + + if (self->private_impl.f_bitstream_ri <= 0) { + } else if (self->private_impl.f_bitstream_ri == self->private_impl.f_bitstream_wi) { + self->private_impl.f_bitstream_ri = 0; + self->private_impl.f_bitstream_wi = 0; + } else { + v_i = 0; + while (self->private_impl.f_bitstream_ri < self->private_impl.f_bitstream_wi) { + self->private_data.f_bitstream_buffer[v_i] = self->private_data.f_bitstream_buffer[self->private_impl.f_bitstream_ri]; + self->private_impl.f_bitstream_ri += 1; + v_i += 1; + if (v_i >= self->private_impl.f_bitstream_ri) { + goto label__0__break; + } + } + label__0__break:; + self->private_impl.f_bitstream_ri = 0; + self->private_impl.f_bitstream_wi = v_i; + } + v_wi = self->private_impl.f_bitstream_wi; + while ((v_wi < 2048) && (((uint64_t)(io2_a_src - iop_a_src)) > 0)) { + v_c = wuffs_base__peek_u8be__no_bounds_check(iop_a_src); + if (v_c < 255) { + self->private_data.f_bitstream_buffer[v_wi] = v_c; + v_wi += 1; + iop_a_src += 1; + } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 1) { + goto label__1__break; + } else if ((wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8) > 0) { + goto label__1__break; + } else { + self->private_data.f_bitstream_buffer[v_wi] = 255; + v_wi += 1; + iop_a_src += 2; + } + } + label__1__break:; + if (((uint64_t)(io2_a_src - iop_a_src)) > 1) { + if ((wuffs_base__peek_u8be__no_bounds_check(iop_a_src) >= 255) && ((wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8) > 0)) { + v_n = (wuffs_base__u32__min(v_wi, 2016) + 32); + while (v_wi < v_n) { + self->private_data.f_bitstream_buffer[v_wi] = 0; + v_wi += 1; + } + } + } + self->private_impl.f_bitstream_wi = v_wi; + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return wuffs_base__make_empty_struct(); +} + +// -------- func jpeg.decoder.skip_past_the_next_restart_marker + +static wuffs_base__status +wuffs_jpeg__decoder__skip_past_the_next_restart_marker( + wuffs_jpeg__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c = 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 && a_src->data.ptr) { + 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_skip_past_the_next_restart_marker[0]; + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + label__0__continue:; + while (true) { + if (((uint64_t)(io2_a_src - iop_a_src)) < 2) { + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); + goto label__0__continue; + } else if (wuffs_base__peek_u8be__no_bounds_check(iop_a_src) < 255) { + iop_a_src += 1; + goto label__0__continue; + } + v_c = ((uint8_t)((wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8))); + if (v_c < 192) { + iop_a_src += 2; + goto label__0__continue; + } else if ((v_c < 208) || (215 < v_c)) { + goto label__0__break; + } + v_c &= 7; + if ((self->private_impl.f_next_restart_marker == ((v_c + 1) & 7)) || (self->private_impl.f_next_restart_marker == ((v_c + 2) & 7))) { + goto label__0__break; + } else if ((self->private_impl.f_next_restart_marker == ((v_c + 7) & 7)) || (self->private_impl.f_next_restart_marker == ((v_c + 6) & 7))) { + iop_a_src += 2; + goto label__0__continue; + } else { + iop_a_src += 2; + goto label__0__break; + } + } + label__0__break:; + self->private_impl.f_next_restart_marker = (((uint8_t)(self->private_impl.f_next_restart_marker + 1)) & 7); + + ok: + self->private_impl.p_skip_past_the_next_restart_marker[0] = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_skip_past_the_next_restart_marker[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + + goto exit; + exit: + if (a_src && a_src->data.ptr) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + + return status; +} + // -------- func jpeg.decoder.swizzle static wuffs_base__status @@ -37570,6 +37823,198 @@ wuffs_jpeg__decoder__workbuf_len( return wuffs_base__utility__make_range_ii_u64(0, 0); } +// -------- func jpeg.decoder.decode_mcu + +static uint32_t +wuffs_jpeg__decoder__decode_mcu( + wuffs_jpeg__decoder* self) { + uint32_t v_ret = 0; + uint64_t v_bits = 0; + uint32_t v_n_bits = 0; + uint8_t v_csel = 0; + wuffs_base__io_buffer u_r = wuffs_base__empty_io_buffer(); + wuffs_base__io_buffer* v_r = &u_r; + const uint8_t* iop_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io0_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io1_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + const uint8_t* io2_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint32_t v_pos = 0; + uint8_t v_dc_h = 0; + uint32_t v_dc_symbol = 0; + uint32_t v_dc_ht_fast = 0; + uint32_t v_dc_bl = 0; + uint32_t v_dc_code = 0; + uint32_t v_dc_blm1 = 0; + uint32_t v_dc_ht_slow = 0; + uint32_t v_dc_value = 0; + uint8_t v_ac_h = 0; + uint32_t v_ac_symbol = 0; + uint32_t v_ac_ht_fast = 0; + uint32_t v_ac_bl = 0; + uint32_t v_ac_code = 0; + uint32_t v_ac_blm1 = 0; + uint32_t v_ac_ht_slow = 0; + uint32_t v_ac_value = 0; + uint32_t v_ac_rrrr = 0; + uint32_t v_ac_ssss = 0; + uint32_t v_z = 0; + + v_bits = self->private_impl.f_bitstream_bits; + v_n_bits = self->private_impl.f_bitstream_n_bits; + if (self->private_impl.f_bitstream_ri > self->private_impl.f_bitstream_wi) { + return 2; + } + { + wuffs_base__io_buffer* o_0_v_r = v_r; + const uint8_t *o_0_iop_v_r = iop_v_r; + const uint8_t *o_0_io0_v_r = io0_v_r; + const uint8_t *o_0_io1_v_r = io1_v_r; + const uint8_t *o_0_io2_v_r = io2_v_r; + v_r = wuffs_base__io_reader__set( + &u_r, + &iop_v_r, + &io0_v_r, + &io1_v_r, + &io2_v_r, + wuffs_base__make_slice_u8_ij(self->private_data.f_bitstream_buffer, + self->private_impl.f_bitstream_ri, + self->private_impl.f_bitstream_wi), + ((uint64_t)(self->private_impl.f_bitstream_ri))); + while (true) { + while (self->private_impl.f_mcu_current_block < self->private_impl.f_mcu_num_blocks) { + while (self->private_impl.f_mcu_zig_index <= 0) { + if (((uint64_t)(io2_v_r - iop_v_r)) < 8) { + v_ret = 1; + goto label__goto_done__break; + } + v_bits |= (wuffs_base__peek_u64be__no_bounds_check(iop_v_r) >> (v_n_bits & 63)); + iop_v_r += ((63 - (v_n_bits & 63)) >> 3); + v_n_bits |= 56; + v_dc_h = (0 | self->private_impl.f_scan_comps_td[self->private_impl.f_mcu_blocks_sselector[self->private_impl.f_mcu_current_block]]); + v_dc_ht_fast = ((uint32_t)(self->private_impl.f_huff_tables_fast[v_dc_h][(v_bits >> 56)])); + v_dc_bl = (v_dc_ht_fast >> 8); + if (v_n_bits >= v_dc_bl) { + v_dc_symbol = (15 & v_dc_ht_fast); + v_bits <<= (v_dc_bl & 63); + v_n_bits -= v_dc_bl; + } else { + v_dc_code = ((uint32_t)((v_bits >> 55))); + v_dc_blm1 = 8; + v_bits <<= 9; + v_n_bits -= 9; + while (true) { + v_dc_ht_slow = self->private_impl.f_huff_tables_slow[v_dc_h][v_dc_blm1]; + if (v_dc_code < (v_dc_ht_slow >> 8)) { + v_dc_symbol = (15 & ((uint32_t)(self->private_impl.f_huff_tables_symbols[v_dc_h][(255 & ((uint32_t)(v_dc_code + v_dc_ht_slow)))]))); + goto label__0__break; + } + v_dc_code = (((uint32_t)(v_dc_code << 1)) | ((uint32_t)((v_bits >> 63)))); + v_bits <<= 1; + v_n_bits -= 1; + v_dc_blm1 = ((v_dc_blm1 + 1) & 15); + if (v_dc_blm1 == 0) { + v_dc_symbol = 0; + goto label__0__break; + } + } + label__0__break:; + } + v_dc_value = ((uint32_t)((((v_bits >> 32) >> (32 - v_dc_symbol)) & 4294967295))); + if ((v_bits >> 63) == 0) { + v_dc_value += ((uint32_t)(1 + ((uint32_t)(((uint32_t)(4294967295)) << v_dc_symbol)))); + } + v_bits <<= v_dc_symbol; + v_n_bits -= v_dc_symbol; + v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[self->private_impl.f_mcu_current_block]]; + self->private_impl.f_mcu_previous_dc_values[v_csel] += ((uint16_t)((v_dc_value & 65535))); + self->private_data.f_mcu_blocks[self->private_impl.f_mcu_current_block][0] = self->private_impl.f_mcu_previous_dc_values[v_csel]; + self->private_impl.f_mcu_zig_index = 1; + goto label__dc_component__break; + } + label__dc_component__break:; + while (true) { + if (((uint64_t)(io2_v_r - iop_v_r)) < 8) { + v_ret = 1; + goto label__goto_done__break; + } + v_bits |= (wuffs_base__peek_u64be__no_bounds_check(iop_v_r) >> (v_n_bits & 63)); + iop_v_r += ((63 - (v_n_bits & 63)) >> 3); + v_n_bits |= 56; + v_ac_h = (4 | self->private_impl.f_scan_comps_ta[self->private_impl.f_mcu_blocks_sselector[self->private_impl.f_mcu_current_block]]); + v_ac_ht_fast = ((uint32_t)(self->private_impl.f_huff_tables_fast[v_ac_h][(v_bits >> 56)])); + v_ac_bl = (v_ac_ht_fast >> 8); + if (v_n_bits >= v_ac_bl) { + v_ac_symbol = (255 & v_ac_ht_fast); + v_bits <<= (v_ac_bl & 63); + v_n_bits -= v_ac_bl; + } else { + v_ac_code = ((uint32_t)((v_bits >> 55))); + v_ac_blm1 = 8; + v_bits <<= 9; + v_n_bits -= 9; + while (true) { + v_ac_ht_slow = self->private_impl.f_huff_tables_slow[v_ac_h][v_ac_blm1]; + if (v_ac_code < (v_ac_ht_slow >> 8)) { + v_ac_symbol = ((uint32_t)(self->private_impl.f_huff_tables_symbols[v_ac_h][(255 & ((uint32_t)(v_ac_code + v_ac_ht_slow)))])); + goto label__1__break; + } + v_ac_code = (((uint32_t)(v_ac_code << 1)) | ((uint32_t)((v_bits >> 63)))); + v_bits <<= 1; + v_n_bits -= 1; + v_ac_blm1 = ((v_ac_blm1 + 1) & 15); + if (v_ac_blm1 == 0) { + v_ac_symbol = 0; + goto label__1__break; + } + } + label__1__break:; + } + v_ac_rrrr = (v_ac_symbol >> 4); + v_ac_ssss = (v_ac_symbol & 15); + if (v_ac_ssss > 0) { + v_ac_value = ((uint32_t)(((v_bits >> (64 - v_ac_ssss)) & 4294967295))); + if ((v_bits >> 63) == 0) { + v_ac_value += ((uint32_t)(1 + ((uint32_t)(((uint32_t)(4294967295)) << v_ac_ssss)))); + } + v_bits <<= v_ac_ssss; + v_n_bits -= v_ac_ssss; + v_z = (self->private_impl.f_mcu_zig_index + v_ac_rrrr); + self->private_data.f_mcu_blocks[self->private_impl.f_mcu_current_block][WUFFS_JPEG__UNZIG[v_z]] = ((uint16_t)((v_ac_value & 65535))); + if ((v_z + 1) > 63) { + goto label__ac_components__break; + } + self->private_impl.f_mcu_zig_index = (v_z + 1); + } else if ((v_ac_rrrr < 15) || ((self->private_impl.f_mcu_zig_index + 16) > 63)) { + goto label__ac_components__break; + } else { + self->private_impl.f_mcu_zig_index = (self->private_impl.f_mcu_zig_index + 16); + } + } + label__ac_components__break:; + self->private_impl.f_mcu_zig_index = 0; + self->private_impl.f_mcu_current_block += 1; + } + self->private_impl.f_mcu_current_block = 0; + goto label__goto_done__break; + } + label__goto_done__break:; + v_pos = ((uint32_t)((wuffs_base__u64__sat_add((v_r ? v_r->meta.pos : 0), ((uint64_t)(iop_v_r - io0_v_r))) & 4294967295))); + if (v_pos > self->private_impl.f_bitstream_wi) { + v_ret = 2; + } else { + self->private_impl.f_bitstream_ri = v_pos; + } + v_r = o_0_v_r; + iop_v_r = o_0_iop_v_r; + io0_v_r = o_0_io0_v_r; + io1_v_r = o_0_io1_v_r; + io2_v_r = o_0_io2_v_r; + } + self->private_impl.f_bitstream_bits = v_bits; + self->private_impl.f_bitstream_n_bits = v_n_bits; + return v_ret; +} + #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__JPEG) #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__JSON) diff --git a/std/jpeg/common_consts.wuffs b/std/jpeg/common_consts.wuffs index 5a3b3787..e507bb21 100644 --- a/std/jpeg/common_consts.wuffs +++ b/std/jpeg/common_consts.wuffs @@ -15,7 +15,7 @@ // UNZIG maps from the zig-zag ordering to the natural ordering. For example, // UNZIG[3] is the column and row of the fourth element in zig-zag order. The // value is 16, which means first column (16%8 == 0) and third row (16/8 == 2). -pri const UNZIG : roarray[64] base.u8[..= 63] = [ +pri const UNZIG : roarray[80] base.u8[..= 63] = [ 0x00, 0x01, 0x08, 0x10, 0x09, 0x02, 0x03, 0x0A, 0x11, 0x18, 0x20, 0x19, 0x12, 0x0B, 0x04, 0x05, 0x0C, 0x13, 0x1A, 0x21, 0x28, 0x30, 0x29, 0x22, @@ -24,4 +24,9 @@ pri const UNZIG : roarray[64] base.u8[..= 63] = [ 0x1D, 0x16, 0x0F, 0x17, 0x1E, 0x25, 0x2C, 0x33, 0x3A, 0x3B, 0x34, 0x2D, 0x26, 0x1F, 0x27, 0x2E, 0x35, 0x3C, 0x3D, 0x36, 0x2F, 0x37, 0x3E, 0x3F, + // The 16 extra elements are for invalid JPEGs where "the z in UNZIG[z] + // overflows 63, when saving the AC value". This isn't in the spec but + // matches how libjpeg-turbo treats "above 63". + 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, + 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, ] diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs index 88009b79..a6fa1846 100644 --- a/std/jpeg/decode_jpeg.wuffs +++ b/std/jpeg/decode_jpeg.wuffs @@ -32,6 +32,8 @@ pub status "#unsupported precision (12 bits)" pub status "#unsupported precision (16 bits)" pub status "#unsupported precision" +pri status "#internal error: inconsistent decoder state" + pub const DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE : base.u64 = 0 pub struct decoder? implements base.image_decoder( @@ -42,7 +44,8 @@ pub struct decoder? implements base.image_decoder( // (/doc/std/image-decoders-call-sequence.md). call_sequence : base.u8, - sof_marker : base.u8, + sof_marker : base.u8, + next_restart_marker : base.u8[..= 7], max_incl_components_h : base.u8[..= 4], max_incl_components_v : base.u8[..= 4], @@ -70,18 +73,29 @@ pub struct decoder? implements base.image_decoder( scan_height_in_mcus : base.u32[..= 0x2000], mcu_num_blocks : base.u32[..= 10], + mcu_current_block : base.u32[..= 10], mcu_blocks_sselector : array[16] base.u8[..= 3], + mcu_zig_index : base.u32[..= 63], - payload_length : base.u32[..= 0xFFFF], + mcu_previous_dc_values : array[4] base.u16, restart_interval : base.u16, saved_restart_interval : base.u16, + restarts_remaining : base.u16, frame_config_io_position : base.u64, + payload_length : base.u32[..= 0xFFFF], + seen_dqt : array[4] base.bool, seen_dht : array[8] base.bool, + // These fields yield bitstream bits in Most Significant Bits order. + bitstream_bits : base.u64, + bitstream_n_bits : base.u32, + bitstream_ri : base.u32[..= 0x800], + bitstream_wi : base.u32[..= 0x800], + quant_tables : array[4] array[64] base.u8, // huff_tables_symbols[(tc*4)|th][i] is the i'th Huffman code's symbol. @@ -102,6 +116,10 @@ pub struct decoder? implements base.image_decoder( swizzler : base.pixel_swizzler, util : base.utility, ) + ( + bitstream_buffer : array[0x800] base.u8, // 0x800 = 2048. + + mcu_blocks : array[10] array[64] base.u16, + // The dht_temp_etc fields are decode_dht temporary values. // dht_temp_counts[n] is the number of codes with bit-length (n+1). @@ -785,7 +803,7 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas // Calculate huff_tables_fast[args.tc4_th]. i = 0 while i < 256 { - this.huff_tables_fast[args.tc4_th][i] = 0 + this.huff_tables_fast[args.tc4_th][i] = 0xFFFF i += 1 } endwhile j = 0 @@ -820,14 +838,29 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas } pri func decoder.decode_sos?(dst: ptr base.pixel_buffer, src: base.io_reader, workbuf: slice base.u8) { - var restarts : base.u32 - var my : base.u32 - var mx : base.u32 - var status : base.status + var my : base.u32 + var mx : base.u32 + var decode_mcu_result : base.u32 + var bitstream_length : base.u32 + var i : base.u32 + var j : base.u32 + var status : base.status this.prepare_scan?(src: args.src) - restarts = this.restart_interval as base.u32 + // Reset. + this.next_restart_marker = 0 + this.restarts_remaining = this.restart_interval + this.mcu_previous_dc_values[0] = 0 + this.mcu_previous_dc_values[1] = 0 + this.mcu_previous_dc_values[2] = 0 + this.mcu_previous_dc_values[3] = 0 + this.bitstream_bits = 0 + this.bitstream_n_bits = 0 + this.bitstream_ri = 0 + this.bitstream_wi = 0 + this.fill_bitstream!(src: args.src) + my = 0 while my < this.scan_height_in_mcus { assert my < 0x2000 via "a < b: a < c; c <= b"(c: this.scan_height_in_mcus) @@ -836,13 +869,69 @@ pri func decoder.decode_sos?(dst: ptr base.pixel_buffer, src: base.io_reader, wo inv my < 0x2000, { assert mx < 0x2000 via "a < b: a < c; c <= b"(c: this.scan_width_in_mcus) + this.mcu_current_block = 0 + this.mcu_zig_index = 0 - // TODO: decode the MCU. + while.decode_mcu true, + inv my < 0x2000, + inv mx < 0x2000, + { + decode_mcu_result = this.decode_mcu!() + if decode_mcu_result == 0 { + break.decode_mcu + } else if decode_mcu_result <> 1 { + return "#internal error: inconsistent decoder state" + } - if restarts > 0 { - restarts -= 1 - if restarts == 0 { - // TODO. + while.fill_bitstream true, + inv my < 0x2000, + inv mx < 0x2000, + { + bitstream_length = this.bitstream_wi ~mod- this.bitstream_ri + this.fill_bitstream!(src: args.src) + if bitstream_length < (this.bitstream_wi ~mod- this.bitstream_ri) { + break.fill_bitstream + } + yield? base."$short read" + } endwhile.fill_bitstream + } endwhile.decode_mcu + + // TODO: IDCT on this.mcu_blocks. + + // Clear this.mcu_blocks. + i = 0 + j = 0 + while i < this.mcu_num_blocks, + inv my < 0x2000, + inv mx < 0x2000, + { + assert i < 10 via "a < b: a < c; c <= b"(c: this.mcu_num_blocks) + while j < 64, + inv my < 0x2000, + inv mx < 0x2000, + inv i < 10, + { + this.mcu_blocks[i][j] = 0 + j += 1 + } endwhile + i += 1 + } endwhile + + if this.restarts_remaining > 0 { + this.restarts_remaining -= 1 + if this.restarts_remaining == 0 { + this.skip_past_the_next_restart_marker?(src: args.src) + + // Reset. + this.restarts_remaining = this.restart_interval + this.mcu_previous_dc_values[0] = 0 + this.mcu_previous_dc_values[1] = 0 + this.mcu_previous_dc_values[2] = 0 + this.mcu_previous_dc_values[3] = 0 + this.bitstream_bits = 0 + this.bitstream_n_bits = 0 + this.bitstream_ri = 0 + this.bitstream_wi = 0 } } @@ -1005,6 +1094,122 @@ pri func decoder.prepare_scan?(src: base.io_reader) { } } +pri func decoder.fill_bitstream!(src: base.io_reader) { + var i : base.u32[..= 0x800] + var wi : base.u32[..= 0x800] + var c : base.u8 + var n : base.u32[..= 0x800] + + // Compact unread bytes to the start of the buffer. + if this.bitstream_ri <= 0 { + // No-op. + } else if this.bitstream_ri == this.bitstream_wi { + this.bitstream_ri = 0 + this.bitstream_wi = 0 + } else { + // TODO: have a built-in (calling memmove) to compact a slice? + i = 0 + assert i < this.bitstream_ri via "a < b: a == c; c < b"(c: 0) + while this.bitstream_ri < this.bitstream_wi, + pre i < this.bitstream_ri, + { + assert this.bitstream_ri < 0x800 via "a < b: a < c; c <= b"(c: this.bitstream_wi) + assert i < 0x800 via "a < b: a < c; c < b"(c: this.bitstream_ri) + this.bitstream_buffer[i] = this.bitstream_buffer[this.bitstream_ri] + this.bitstream_ri += 1 + i += 1 + // TODO: this if statement should be unnecessary. Instead, we + // should be able to "assert i < this.bitstream_ri". + if i >= this.bitstream_ri { + break // Unreachable. + } + } endwhile + this.bitstream_ri = 0 + this.bitstream_wi = i + } + + wi = this.bitstream_wi + while (wi < 0x800) and (args.src.length() > 0) { + c = args.src.peek_u8() + if c < 0xFF { + this.bitstream_buffer[wi] = c + wi += 1 + args.src.skip_u32_fast!(actual: 1, worst_case: 1) + + } else if args.src.length() <= 1 { + break + + } else if (args.src.peek_u16le() >> 8) > 0 { + break + + } else { + this.bitstream_buffer[wi] = 0xFF + wi += 1 + args.src.skip_u32_fast!(actual: 2, worst_case: 2) + } + } endwhile + + // If we hit a "\xFF\x??" marker then pad the bitstream. In this method + // invocation, insert up to 32 bytes of implicit zeroes. Repeated calls to + // this method can insert even more. + if args.src.length() > 1 { + if (args.src.peek_u8() >= 0xFF) and ((args.src.peek_u16le() >> 8) > 0) { + n = wi.min(no_more_than: 0x800 - 32) + 32 + while wi < n { + assert wi < 0x800 via "a < b: a < c; c <= b"(c: n) + this.bitstream_buffer[wi] = 0x00 + wi += 1 + } endwhile + } + } + + this.bitstream_wi = wi +} + +pri func decoder.skip_past_the_next_restart_marker?(src: base.io_reader) { + var c : base.u8 + + while true { + if args.src.length() < 2 { + yield? base."$short read" + continue + } else if args.src.peek_u8() < 0xFF { + args.src.skip_u32_fast!(actual: 1, worst_case: 1) + continue + } + + c = (args.src.peek_u16le() >> 8) as base.u8 + if c < 0xC0 { + // Either a reserved marker or "\xFF\x00" byte stuffing. Consume it + // and continue. + args.src.skip_u32_fast!(actual: 2, worst_case: 2) + continue + } else if (c < 0xD0) or (0xD7 < c) { + // Not an RSTn (Restart) marker. Leave it and break. + break + } + + c &= 7 + if (this.next_restart_marker == ((c + 1) & 7)) or + (this.next_restart_marker == ((c + 2) & 7)) { + // A leading RSTn marker. Leave it and break. + break + } else if (this.next_restart_marker == ((c + 7) & 7)) or + (this.next_restart_marker == ((c + 6) & 7)) { + // A lagging RSTn marker. Consume it and continue. + args.src.skip_u32_fast!(actual: 2, worst_case: 2) + continue + } else { + // The RSTn marker is either the expected one or far away from the + // expected one (neither leading or lagging). Consume it and break. + args.src.skip_u32_fast!(actual: 2, worst_case: 2) + break + } + } endwhile + + this.next_restart_marker = (this.next_restart_marker ~mod+ 1) & 7 +} + pri func decoder.swizzle!(dst: ptr base.pixel_buffer) base.status { var dst_pixfmt : base.pixel_format var dst_bits_per_pixel : base.u32[..= 256] diff --git a/std/jpeg/decode_mcu_default.wuffs b/std/jpeg/decode_mcu_default.wuffs new file mode 100644 index 00000000..38963798 --- /dev/null +++ b/std/jpeg/decode_mcu_default.wuffs @@ -0,0 +1,214 @@ +// 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 +} diff --git a/test/c/std/jpeg.c b/test/c/std/jpeg.c index 55920f12..cffac60b 100644 --- a/test/c/std/jpeg.c +++ b/test/c/std/jpeg.c @@ -179,7 +179,7 @@ do_test_wuffs_jpeg_decode_dht(wuffs_base__io_buffer* src, if (use_fast) { uint16_t x = (*want_fast)[bits >> 24]; uint32_t n = x >> 8; - if (x == 0) { + if (x == 0xFFFF) { have = err_fast_not_applicable; } else if (n > n_bits) { have = err_not_enough_bits; @@ -344,7 +344,7 @@ test_wuffs_jpeg_decode_dht_easy() { 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, // 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, 0x0408, // 0x0509, 0x0509, 0x0509, 0x0509, 0x0509, 0x0509, 0x0509, 0x0509, // - 0x0602, 0x0602, 0x0602, 0x0602, 0x0701, 0x0701, 0x0000, 0x0000, // + 0x0602, 0x0602, 0x0602, 0x0602, 0x0701, 0x0701, 0xFFFF, 0xFFFF, // }; return do_test_wuffs_jpeg_decode_dht(&src, bits, n_bits, want_dst_ptr, @@ -523,7 +523,7 @@ test_wuffs_jpeg_decode_dht_hard() { 0x0607, 0x0607, 0x0607, 0x0607, 0x0612, 0x0612, 0x0612, 0x0612, // 0x0621, 0x0621, 0x0621, 0x0621, 0x0631, 0x0631, 0x0631, 0x0631, // 0x0713, 0x0713, 0x0741, 0x0741, 0x0751, 0x0751, 0x0808, 0x0814, // - 0x0822, 0x0861, 0x0871, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0822, 0x0861, 0x0871, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, // }; return do_test_wuffs_jpeg_decode_dht(&src, bits, n_bits, want_dst_ptr, @@ -531,6 +531,146 @@ test_wuffs_jpeg_decode_dht_hard() { &want_fast); } +const char* // +test_wuffs_jpeg_decode_mcu() { + CHECK_FOCUS(__func__); + + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = g_src_slice_u8, + }); + CHECK_STRING(read_file(&src, "test/data/bricks-color.jpeg")); + + wuffs_jpeg__decoder dec; + CHECK_STATUS("initialize", wuffs_jpeg__decoder__initialize( + &dec, sizeof dec, WUFFS_VERSION, + WUFFS_INITIALIZE__DEFAULT_OPTIONS)); + + // Decode the 0xC0 SOF marker, four 0xC4 DHT markers and 0xDA SOS marker. The + // SOS marker is only partially processed, since complete SOS processing + // would call wuffs_jpeg__decoder__decode_mcu multiple times. + const uint32_t marker_positions[6] = // + {0x09E, 0x0B1, 0x0D0, 0x114, 0x133, 0x16E}; + for (int i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(marker_positions); i++) { + uint8_t want_marker = (i <= 0) ? 0xC0 : ((i <= 4) ? 0xC4 : 0xDA); + src.meta.ri = marker_positions[i]; + if ((src.meta.ri + 4) > src.meta.wi) { + RETURN_FAIL("seek #%d: past EOF", i); + } else if (src.data.ptr[src.meta.ri++] != 0xFF) { + RETURN_FAIL("seek #%d: have 0x%02X, want 0x%02X", i, + src.data.ptr[src.meta.ri - 1], 0xFF); + } else if (src.data.ptr[src.meta.ri++] != want_marker) { + RETURN_FAIL("seek #%d: have 0x%02X, want 0x%02X", i, + src.data.ptr[src.meta.ri - 1], want_marker); + } + + dec.private_impl.f_payload_length = 0; + dec.private_impl.f_payload_length |= src.data.ptr[src.meta.ri++]; + dec.private_impl.f_payload_length <<= 8; + dec.private_impl.f_payload_length |= src.data.ptr[src.meta.ri++]; + dec.private_impl.f_payload_length -= 2; + + if (i <= 0) { + dec.private_impl.f_sof_marker = 0xC0; + CHECK_STATUS("decode_sof", wuffs_jpeg__decoder__decode_sof(&dec, &src)); + } else if (i <= 4) { + CHECK_STATUS("decode_dht", wuffs_jpeg__decoder__decode_dht(&dec, &src)); + } else { + CHECK_STATUS("prepare_scan", + wuffs_jpeg__decoder__prepare_scan(&dec, &src)); + wuffs_jpeg__decoder__fill_bitstream(&dec, &src); + } + } + + // Decode and compare-to-golden the first MCU (Minimum Coded Unit). + + if (wuffs_jpeg__decoder__decode_mcu(&dec)) { + RETURN_FAIL("decode_mcu failed"); + } + + // 4:2:0 chroma subsampling means that the MCU has 4 Y, 1 Cb and 1 Cr blocks. + uint16_t wants[10][64] = { + { + 0xFFC9, 0xFFD8, 0x0014, 0xFFF7, 0x0002, 0x0000, 0x0000, 0x0000, // + 0x006A, 0xFFE3, 0x001C, 0xFFF9, 0x0002, 0x0000, 0x0000, 0x0000, // + 0x0015, 0x0002, 0x0002, 0xFFFE, 0x0001, 0x0000, 0x0000, 0x0001, // + 0x000D, 0xFFEC, 0x0005, 0xFFFE, 0x0000, 0x0000, 0x0000, 0x0000, // + 0xFFFA, 0xFFFA, 0x0002, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0001, 0xFFFD, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + }, + { + 0xFFAA, 0x0070, 0x003A, 0xFFE0, 0xFFF9, 0x0004, 0x0000, 0x0001, // + 0x004F, 0x005E, 0x0022, 0x0006, 0xFFF3, 0xFFFD, 0x0004, 0x0000, // + 0xFFF4, 0xFFE8, 0x0002, 0x0012, 0x0003, 0x0000, 0xFFFF, 0x0002, // + 0xFFEC, 0xFFF3, 0x000A, 0x000A, 0x0007, 0x0000, 0xFFFF, 0xFFFF, // + 0xFFF3, 0xFFFB, 0xFFFD, 0x0002, 0x0002, 0x0000, 0x0001, 0x0000, // + 0xFFFC, 0xFFFB, 0xFFFD, 0xFFFF, 0x0000, 0x0002, 0x0001, 0x0001, // + 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0001, 0x0001, 0x0001, // + 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0001, 0x0000, // + }, + { + 0xFF25, 0x000D, 0x0003, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x000E, 0x0006, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0005, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0004, 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0002, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + }, + { + 0xFF59, 0xFFD6, 0xFFCF, 0x000C, 0x0006, 0xFFFE, 0xFFFE, 0x0002, // + 0xFFF3, 0x0013, 0x000C, 0xFFE6, 0x000E, 0x0001, 0xFFFC, 0x0004, // + 0x0010, 0xFFF1, 0x0005, 0x0003, 0xFFFA, 0x0002, 0x0001, 0xFFFE, // + 0xFFF9, 0x0005, 0x0000, 0xFFFE, 0x0002, 0x0000, 0xFFFE, 0x0002, // + 0x0003, 0xFFFF, 0x0000, 0x0001, 0xFFFF, 0x0000, 0x0001, 0xFFFF, // + 0xFFFE, 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + }, + { + 0x0077, 0x000F, 0xFFFA, 0x0001, 0x0000, 0xFFFF, 0x0002, 0xFFFF, // + 0xFFFA, 0x0020, 0xFFF9, 0x0000, 0x0000, 0xFFFF, 0x0001, 0xFFFF, // + 0xFFFA, 0x0008, 0x0000, 0x0000, 0xFFFF, 0x0001, 0x0000, 0x0000, // + 0xFFFE, 0x0001, 0x0001, 0x0001, 0xFFFF, 0x0001, 0xFFFF, 0x0000, // + 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + }, + { + 0xFF88, 0x0003, 0xFFFD, 0x0000, 0x0000, 0x0000, 0xFFFF, 0x0001, // + 0xFFE4, 0xFFEC, 0x0001, 0x0001, 0x0000, 0x0001, 0xFFFF, 0x0001, // + 0xFFFC, 0xFFFC, 0xFFFE, 0x0000, 0x0001, 0xFFFF, 0x0000, 0x0000, // + 0x0001, 0xFFFF, 0xFFFF, 0x0000, 0x0001, 0xFFFF, 0x0000, 0x0000, // + 0x0000, 0x0000, 0xFFFE, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // + }, + {0}, // + {0}, // + {0}, // + {0}, // + }; + + for (int b = 0; b < 10; b++) { + wuffs_base__io_buffer have = wuffs_base__ptr_u8__reader( // + (void*)(&dec.private_data.f_mcu_blocks[b]), // + sizeof(dec.private_data.f_mcu_blocks[b]), true); + wuffs_base__io_buffer want = wuffs_base__ptr_u8__reader( // + (void*)(&wants[b]), // + sizeof(wants[b]), true); + + char prefix[64]; + snprintf(prefix, 64, "b=%d: ", b); + CHECK_STRING(check_io_buffers_equal(prefix, &have, &want)); + } + + return NULL; +} + // ---------------- Mimic Tests #ifdef WUFFS_MIMIC @@ -565,6 +705,7 @@ proc g_tests[] = { test_wuffs_jpeg_decode_dht_easy, test_wuffs_jpeg_decode_dht_hard, + test_wuffs_jpeg_decode_mcu, test_wuffs_jpeg_decode_interface, test_wuffs_jpeg_decode_truncated_input,