std/jpeg: decode Huffman entropy coded data

Updates #42
This commit is contained in:
Nigel Tao committed 2023-05-06 09:47:10 +10:00
1 parent 6fd9767b5d
commit c914f66a6c
5 files changed
+1035 -25

No files matched your search

+453 -8
View File
@@ -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)
+6 -1
View File
@@ -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,
]
+218 -13
View File
@@ -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]
+214
View File
@@ -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
}
+144 -3
View File
@@ -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,