From c9fff5b207dd33beb8f2ac70396b33b13abb3ca2 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 4 Aug 2024 23:15:58 +1000 Subject: [PATCH] std/jpeg: add and use WUFFS_BASE__QUIRK_QUALITY --- doc/changelog.md | 1 + doc/note/quirks.md | 10 + example/imageviewer/imageviewer.cc | 12 +- fuzz/c/std/pixel_swizzler_fuzzer.c | 46 +- internal/cgen/auxiliary/image.cc | 7 + internal/cgen/base/fundamental-public.h | 14 + internal/cgen/base/image-private.h | 6 +- internal/cgen/base/pixconv-submodule-ycck.c | 253 +++++--- lang/builtin/builtin.go | 7 +- release/c/wuffs-unsupported-snapshot.c | 588 +++++++++++++----- std/jpeg/decode_jpeg.wuffs | 258 ++++++-- std/jpeg/decode_mcu_default.wuffs | 63 +- .../decode_mcu_progressive_ac_high_bits.wuffs | 2 +- .../decode_mcu_progressive_ac_low_bit.wuffs | 2 +- .../decode_mcu_progressive_dc_high_bits.wuffs | 2 +- .../decode_mcu_progressive_dc_low_bit.wuffs | 2 +- test/c/std/jpeg.c | 48 +- 17 files changed, 986 insertions(+), 335 deletions(-) diff --git a/doc/changelog.md b/doc/changelog.md index e142dd76..413a29b6 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -26,6 +26,7 @@ The LICENSE has changed from a single license (Apache 2) to a dual license - Added `std/xxhash32`. - Added `std/xxhash64`. - Added `std/xz`. +- Added `WUFFS_BASE__QUIRK_QUALITY`. - Added `WUFFS_CONFIG__DISABLE_MSVC_CPU_ARCH__X86_64_FAMILY`. - Added `WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST`. - Added `WUFFS_CONFIG__ENABLE_MSVC_CPU_ARCH__X86_64_V2`. diff --git a/doc/note/quirks.md b/doc/note/quirks.md index 7ff1b263..4606c529 100644 --- a/doc/note/quirks.md +++ b/doc/note/quirks.md @@ -62,6 +62,16 @@ Common quirks: at a cost of being less able to detect data corruption and to deviate from a strict reading of the relevant file format specifications, accepting some inputs that are technically invalid (but otherwise decode fine). +- `WUFFS_BASE__QUIRK_QUALITY` configures decoders (for a lossy format, where + there is some leeway in "a/the correct decoding") or encoders to use lower + than, equal to or higher than the default quality setting. Lower-than-default + obviously produces a worse result on some measure. But, if the codec behavior + depends on the quirk value, lowering quality can improve other measures: + being faster (less time taken), lighter (less "work buffer" memory required), + etc. Conversely, asking for higher quality might be a no-op (depending on the + codec) but, if it does affect behavior, it typically trades off in the other + direction: higher quality and/or tighter (smaller output) but also slower, + heavier, etc. Package-specific quirks: diff --git a/example/imageviewer/imageviewer.cc b/example/imageviewer/imageviewer.cc index 8ce1b1a3..c68c67c2 100644 --- a/example/imageviewer/imageviewer.cc +++ b/example/imageviewer/imageviewer.cc @@ -132,6 +132,7 @@ struct { int remaining_argc; char** remaining_argv; + bool lower_quality; double screen_gamma; } g_flags = {0}; @@ -139,6 +140,7 @@ static const char* g_usage = "Usage: imageviewer -flags input0.gif input1.png\n" "\n" "Flags:\n" + " -lower-quality (exercise lower-image-quality code paths)\n" " -screen_gamma=N.N (default 2.2; 0 disables gamma correction)"; const char* // @@ -165,6 +167,10 @@ parse_flags(int argc, char** argv) { } } + if (!strcmp(arg, "lower-quality")) { + g_flags.lower_quality = true; + continue; + } if (!strncmp(arg, "screen_gamma=", 13)) { g_flags.screen_gamma = atof(arg + 13); continue; @@ -265,10 +271,14 @@ load_image(const char* filename) { dia_flags |= wuffs_aux::DecodeImageArgFlags::REPORT_METADATA_GAMA; } + uint32_t wuffs_base__quirk_quality = WUFFS_BASE__QUIRK_QUALITY; + MyDecodeImageCallbacks callbacks; wuffs_aux::sync_io::FileInput input(file); wuffs_aux::DecodeImageResult res = wuffs_aux::DecodeImage( - callbacks, input, wuffs_aux::DecodeImageArgQuirks::DefaultValue(), + callbacks, input, + wuffs_aux::DecodeImageArgQuirks(&wuffs_base__quirk_quality, + g_flags.lower_quality ? 1 : 0), wuffs_aux::DecodeImageArgFlags(dia_flags), // Use PIXEL_BLEND__SRC_OVER, not the default PIXEL_BLEND__SRC, because // we also pass a background color. diff --git a/fuzz/c/std/pixel_swizzler_fuzzer.c b/fuzz/c/std/pixel_swizzler_fuzzer.c index 4e59ab3c..41bffdcf 100644 --- a/fuzz/c/std/pixel_swizzler_fuzzer.c +++ b/fuzz/c/std/pixel_swizzler_fuzzer.c @@ -214,16 +214,34 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { wuffs_base__pixel_format dst_pixfmt = wuffs_base__make_pixel_format( pixfmts[(0xFF & (hash >> 0)) % num_pixfmts]); - uint32_t width = (63 & (hash >> 8)) + 1; - uint32_t height = (63 & (hash >> 14)) + 1; + uint32_t x_min_incl = (63 & (hash >> 8)) + 1; + uint32_t x_max_excl = (63 & (hash >> 14)) + 1; + uint32_t y_min_incl = (63 & (hash >> 20)) + 1; + uint32_t y_max_excl = (63 & (hash >> 26)) + 1; - uint32_t width_in_mcus = (3 & (hash >> 20)) + 1; - uint32_t height_in_mcus = (3 & (hash >> 22)) + 1; + uint32_t width_in_mcus = (3 & (hash >> 32)) + 1; + uint32_t height_in_mcus = (3 & (hash >> 34)) + 1; - uint32_t allow_hv3 = 1 & (hash >> 24); - bool is_rgb_or_cmyk = 1 & (hash >> 25); - bool triangle_filter_for_2to1 = 1 & (hash >> 26); - bool use_4th_component = 1 & (hash >> 27); + uint32_t allow_hv3 = 1 & (hash >> 36); + bool is_rgb_or_cmyk = 1 & (hash >> 37); + bool triangle_filter_for_2to1 = 1 & (hash >> 38); + bool use_4th_component = 1 & (hash >> 39); + + if (triangle_filter_for_2to1) { + x_min_incl = 0; + y_min_incl = 0; + } else { + if (x_min_incl > x_max_excl) { + uint32_t a = x_min_incl; + x_min_incl = x_max_excl; + x_max_excl = a; + } + if (y_min_incl > y_max_excl) { + uint32_t a = y_min_incl; + y_min_incl = y_max_excl; + y_max_excl = a; + } + } uint32_t possible_hv_values[2][4] = { {1, 1, 2, 4}, @@ -253,8 +271,10 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { h0, wuffs_base__u32__max(h1, wuffs_base__u32__max(h2, h3))); uint32_t vmax = wuffs_base__u32__max( v0, wuffs_base__u32__max(v1, wuffs_base__u32__max(v2, v3))); - width = wuffs_base__u32__min(width, 8 * width_in_mcus * hmax); - height = wuffs_base__u32__min(height, 8 * height_in_mcus * vmax); + x_max_excl = x_min_incl + wuffs_base__u32__min(x_max_excl - x_min_incl, + 8 * width_in_mcus * hmax); + y_max_excl = y_min_incl + wuffs_base__u32__min(y_max_excl - y_min_incl, + 8 * height_in_mcus * vmax); static size_t dst_alloc_size = 0; if (dst_alloc_size == 0) { @@ -271,7 +291,8 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { wuffs_base__pixel_buffer dst_pixbuf; wuffs_base__pixel_config dst_pixcfg; - wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, width, height); + wuffs_base__pixel_config__set(&dst_pixcfg, dst_pixfmt.repr, 0, x_max_excl, + y_max_excl); uint64_t dst_pixbuf_len = wuffs_base__pixel_config__pixbuf_len(&dst_pixcfg); if (dst_pixbuf_len > dst_alloc_size) { return "fuzz: internal error: dst_alloc_size is too small"; @@ -368,7 +389,8 @@ fuzz_swizzle_ycck(wuffs_base__io_buffer* src, uint64_t hash) { uint8_t scratch_buffer[2048]; wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck( &swizzler, &dst_pixbuf, dst_palette, // - width, height, // + x_min_incl, x_max_excl, // + y_min_incl, y_max_excl, // src0, src1, src2, src3, // width0, width1, width2, width3, // height0, height1, height2, height3, // diff --git a/internal/cgen/auxiliary/image.cc b/internal/cgen/auxiliary/image.cc index a075c501..fa6fdc73 100644 --- a/internal/cgen/auxiliary/image.cc +++ b/internal/cgen/auxiliary/image.cc @@ -387,6 +387,13 @@ redirect: // Apply quirks. for (size_t i = 0; i < quirks.len; i++) { + // TODO: don't special-case this. + if (quirks.ptr[i] == WUFFS_BASE__QUIRK_QUALITY) { + image_decoder->set_quirk( + WUFFS_BASE__QUIRK_QUALITY, + WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY); + continue; + } image_decoder->set_quirk(quirks.ptr[i], 1); } diff --git a/internal/cgen/base/fundamental-public.h b/internal/cgen/base/fundamental-public.h index 901327c3..7f75a1aa 100644 --- a/internal/cgen/base/fundamental-public.h +++ b/internal/cgen/base/fundamental-public.h @@ -1736,3 +1736,17 @@ wuffs_base__table__flattened_length(size_t width, WUFFS_BASE__MAYBE_STATIC int32_t // wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data, bool prefix_closed); + +// ---------------- Quirk Values + +// These constants are the value half of a key-value pair, where the key is +// WUFFS_BASE__QUIRK_QUALITY. +// +// In the Wuffs API, set_quirk takes a u64 value. These macro definitions are +// likewise unsigned values (uint64_t) but for this particular key, they are +// best interpreted as signed values (int64_t). "Lower-than-default quality" +// and "higher-than-default quality", as signed values, are -1 and +1. +// +// See doc/note/quirks.md for some more discussion about trade-offs. +#define WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY UINT64_MAX +#define WUFFS_BASE__QUIRK_QUALITY__VALUE__HIGHER_QUALITY ((uint64_t)1) diff --git a/internal/cgen/base/image-private.h b/internal/cgen/base/image-private.h index 87797293..4547b0f2 100644 --- a/internal/cgen/base/image-private.h +++ b/internal/cgen/base/image-private.h @@ -39,8 +39,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck( const wuffs_base__pixel_swizzler* p, wuffs_base__pixel_buffer* dst, wuffs_base__slice_u8 dst_palette, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src2, diff --git a/internal/cgen/base/pixconv-submodule-ycck.c b/internal/cgen/base/pixconv-submodule-ycck.c index 1f1ea4b5..0760b749 100644 --- a/internal/cgen/base/pixconv-submodule-ycck.c +++ b/internal/cgen/base/pixconv-submodule-ycck.c @@ -625,8 +625,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( static void // wuffs_private_impl__swizzle_ycck__general__triangle_filter( wuffs_base__pixel_buffer* dst, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, const uint8_t* src_ptr0, const uint8_t* src_ptr1, const uint8_t* src_ptr2, @@ -648,6 +650,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( uint8_t* scratch_buffer_2k_ptr, wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) { + if ((x_min_incl != 0) || (y_min_incl != 0)) { + return; + } + wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = @@ -660,7 +666,7 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( // First row. uint32_t h1v2_bias = 1u; wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( - dst, width, 0u, // + dst, x_max_excl, 0u, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, // stride0, stride1, stride2, stride3, // inv_h0, inv_h1, inv_h2, inv_h3, // @@ -672,10 +678,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( h1v2_bias = 2u; // Middle rows. - bool last_row = height == 2u * half_height_for_2to1; - uint32_t y_max_excl = last_row ? (height - 1u) : height; + bool last_row = y_max_excl == 2u * half_height_for_2to1; + uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; uint32_t y; - for (y = 1u; y < y_max_excl; y++) { + for (y = 1u; y < middle_y_max_excl; y++) { const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_minor = (inv_v0 != 2u) @@ -702,11 +708,11 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( uint32_t total_src_len3 = 0u; uint32_t x = 0u; - while (x < width) { + while (x < x_max_excl) { bool first_column = x == 0u; uint32_t end = x + 480u; - if (end > width) { - end = width; + if (end > x_max_excl) { + end = x_max_excl; } uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; @@ -762,9 +768,9 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( } // Last row. - if (y_max_excl != height) { + if (middle_y_max_excl != y_max_excl) { wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( - dst, width, height - 1u, // + dst, x_max_excl, middle_y_max_excl, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, // stride0, stride1, stride2, stride3, // inv_h0, inv_h1, inv_h2, inv_h3, // @@ -860,8 +866,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( static void // wuffs_private_impl__swizzle_ycc__general__triangle_filter( wuffs_base__pixel_buffer* dst, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, const uint8_t* src_ptr0, const uint8_t* src_ptr1, const uint8_t* src_ptr2, @@ -879,6 +887,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( uint8_t* scratch_buffer_2k_ptr, wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { + if ((x_min_incl != 0) || (y_min_incl != 0)) { + return; + } + wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = @@ -889,7 +901,7 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( // First row. uint32_t h1v2_bias = 1u; wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( - dst, width, 0u, // + dst, x_max_excl, 0u, // src_ptr0, src_ptr1, src_ptr2, // stride0, stride1, stride2, // inv_h0, inv_h1, inv_h2, // @@ -901,10 +913,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( h1v2_bias = 2u; // Middle rows. - bool last_row = height == 2u * half_height_for_2to1; - uint32_t y_max_excl = last_row ? (height - 1u) : height; + bool last_row = y_max_excl == 2u * half_height_for_2to1; + uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; uint32_t y; - for (y = 1u; y < y_max_excl; y++) { + for (y = 1u; y < middle_y_max_excl; y++) { const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_minor = (inv_v0 != 2u) @@ -925,11 +937,11 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( uint32_t total_src_len2 = 0u; uint32_t x = 0u; - while (x < width) { + while (x < x_max_excl) { bool first_column = x == 0u; uint32_t end = x + 672u; - if (end > width) { - end = width; + if (end > x_max_excl) { + end = x_max_excl; } uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; @@ -974,16 +986,16 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( } // Last row. - if (y_max_excl != height) { + if (middle_y_max_excl != y_max_excl) { wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( - dst, width, height - 1u, // - src_ptr0, src_ptr1, src_ptr2, // - stride0, stride1, stride2, // - inv_h0, inv_h1, inv_h2, // - inv_v0, inv_v1, inv_v2, // - half_width_for_2to1, // - h1v2_bias, // - scratch_buffer_2k_ptr, // + dst, x_max_excl, middle_y_max_excl, // + src_ptr0, src_ptr1, src_ptr2, // + stride0, stride1, stride2, // + inv_h0, inv_h1, inv_h2, // + inv_v0, inv_v1, inv_v2, // + half_width_for_2to1, // + h1v2_bias, // + scratch_buffer_2k_ptr, // upfunc0, upfunc1, upfunc2, conv3func); } } @@ -991,8 +1003,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( static void // wuffs_private_impl__swizzle_ycc__general__box_filter( wuffs_base__pixel_buffer* dst, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, const uint8_t* src_ptr0, const uint8_t* src_ptr1, const uint8_t* src_ptr2, @@ -1018,41 +1032,44 @@ wuffs_private_impl__swizzle_ycc__general__box_filter( (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; uint32_t y; - for (y = 0u; y < height; y++) { - const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); - const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); - const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); + for (y = y_min_incl; y < y_max_excl; y++) { + const uint8_t* src0_major = + src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0); + const uint8_t* src1_major = + src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1); + const uint8_t* src2_major = + src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2); - uint32_t x = 0u; - while (x < width) { + uint32_t x = x_min_incl; + while (x < x_max_excl) { uint32_t end = x + 672u; - if (end > width) { - end = width; + if (end > x_max_excl) { + end = x_max_excl; } uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; - const uint8_t* up0 = (*upfunc0)( // - scratch_buffer_2k_ptr + (0u * 672u), // - src0_major + (x / inv_h0), // - src0_major + (x / inv_h0), // - src_len0, // + const uint8_t* up0 = (*upfunc0)( // + scratch_buffer_2k_ptr + (0u * 672u), // + src0_major + ((x - x_min_incl) / inv_h0), // + src0_major + ((x - x_min_incl) / inv_h0), // + src_len0, // 0u, false, false); - const uint8_t* up1 = (*upfunc1)( // - scratch_buffer_2k_ptr + (1u * 672u), // - src1_major + (x / inv_h1), // - src1_major + (x / inv_h1), // - src_len1, // + const uint8_t* up1 = (*upfunc1)( // + scratch_buffer_2k_ptr + (1u * 672u), // + src1_major + ((x - x_min_incl) / inv_h1), // + src1_major + ((x - x_min_incl) / inv_h1), // + src_len1, // 0u, false, false); - const uint8_t* up2 = (*upfunc2)( // - scratch_buffer_2k_ptr + (2u * 672u), // - src2_major + (x / inv_h2), // - src2_major + (x / inv_h2), // - src_len2, // + const uint8_t* up2 = (*upfunc2)( // + scratch_buffer_2k_ptr + (2u * 672u), // + src2_major + ((x - x_min_incl) / inv_h2), // + src2_major + ((x - x_min_incl) / inv_h2), // + src_len2, // 0u, false, false); (*conv3func)(dst, x, end, y, up0, up1, up2); @@ -1085,8 +1102,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck( const wuffs_base__pixel_swizzler* p, wuffs_base__pixel_buffer* dst, wuffs_base__slice_u8 dst_palette, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src2, @@ -1116,13 +1135,19 @@ wuffs_base__pixel_swizzler__swizzle_ycck( wuffs_base__slice_u8 scratch_buffer_2k) { if (!p) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); - } else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || // - (4u <= ((unsigned int)h0 - 1u)) || // - (4u <= ((unsigned int)h1 - 1u)) || // - (4u <= ((unsigned int)h2 - 1u)) || // - (4u <= ((unsigned int)v0 - 1u)) || // - (4u <= ((unsigned int)v1 - 1u)) || // - (4u <= ((unsigned int)v2 - 1u)) || // + } else if (!dst || // + (x_min_incl > x_max_excl) || // + (x_max_excl > 0xFFFFu) || // + (y_min_incl > y_max_excl) || // + (y_max_excl > 0xFFFFu) || // + (4u <= ((unsigned int)h0 - 1u)) || // + (4u <= ((unsigned int)h1 - 1u)) || // + (4u <= ((unsigned int)h2 - 1u)) || // + (4u <= ((unsigned int)v0 - 1u)) || // + (4u <= ((unsigned int)v1 - 1u)) || // + (4u <= ((unsigned int)v2 - 1u)) || // + (triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) || + (!triangle_filter_for_2to1 && ((h3 | v3) > 0u)) || (scratch_buffer_2k.len < 2048u)) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } @@ -1149,21 +1174,69 @@ wuffs_base__pixel_swizzler__swizzle_ycck( uint32_t inv_v2 = max_incl_v / v2; uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; - uint32_t half_width_for_2to1 = (width + 1u) / 2u; - uint32_t half_height_for_2to1 = (height + 1u) / 2u; + if (x_min_incl != 0) { + if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) || + (x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + } + if (y_min_incl != 0) { + if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) || + (y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + } - width = wuffs_private_impl__u32__min_of_5( // - width, // - width0 * inv_h0, // - width1 * inv_h1, // - width2 * inv_h2, // - wuffs_base__pixel_config__width(&dst->pixcfg)); - height = wuffs_private_impl__u32__min_of_5( // - height, // - height0 * inv_v0, // - height1 * inv_v1, // - height2 * inv_v2, // - wuffs_base__pixel_config__height(&dst->pixcfg)); + uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u; + if (inv_h0 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0); + } + if (inv_h1 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1); + } + if (inv_h2 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2); + } + if (inv_h3 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3); + } + + uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u; + if (inv_v0 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0); + } + if (inv_v1 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1); + } + if (inv_v2 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2); + } + if (inv_v3 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3); + } + + x_max_excl = wuffs_base__u32__min( // + wuffs_base__pixel_config__width(&dst->pixcfg), // + x_min_incl + wuffs_private_impl__u32__min_of_5( // + x_max_excl - x_min_incl, // + width0 * inv_h0, // + width1 * inv_h1, // + width2 * inv_h2, // + inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF)); + y_max_excl = wuffs_base__u32__min( // + wuffs_base__pixel_config__height(&dst->pixcfg), // + y_min_incl + wuffs_private_impl__u32__min_of_5( // + y_max_excl - y_min_incl, // + height0 * inv_v0, // + height1 * inv_v1, // + height2 * inv_v2, // + inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF)); + + if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) { + return wuffs_base__make_status(NULL); + } + uint32_t width = x_max_excl - x_min_incl; + uint32_t height = y_max_excl - y_min_incl; if (((h0 * inv_h0) != max_incl_h) || // ((h1 * inv_h1) != max_incl_h) || // @@ -1264,10 +1337,6 @@ wuffs_base__pixel_swizzler__swizzle_ycck( // ---- - if ((width <= 0u) || (height <= 0u)) { - return wuffs_base__make_status(NULL); - } - wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; if (is_rgb_or_cmyk) { @@ -1303,8 +1372,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck( } void (*func)(wuffs_base__pixel_buffer * dst, // - uint32_t width, // - uint32_t height, // + uint32_t x_min_incl, // + uint32_t x_max_excl, // + uint32_t y_min_incl, // + uint32_t y_max_excl, // const uint8_t* src_ptr0, // const uint8_t* src_ptr1, // const uint8_t* src_ptr2, // @@ -1365,7 +1436,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck( is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general : &wuffs_private_impl__swizzle_ycck__convert_4_general; wuffs_private_impl__swizzle_ycck__general__triangle_filter( // - dst, width, height, // + dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // src0.ptr, src1.ptr, src2.ptr, src3.ptr, // stride0, stride1, stride2, stride3, // inv_h0, inv_h1, inv_h2, inv_h3, // @@ -1374,13 +1445,13 @@ wuffs_base__pixel_swizzler__swizzle_ycck( scratch_buffer_2k.ptr, &upfuncs, conv4func); } else { - (*func)( // - dst, width, height, // - src0.ptr, src1.ptr, src2.ptr, // - stride0, stride1, stride2, // - inv_h0, inv_h1, inv_h2, // - inv_v0, inv_v1, inv_v2, // - half_width_for_2to1, half_height_for_2to1, // + (*func)( // + dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // + src0.ptr, src1.ptr, src2.ptr, // + stride0, stride1, stride2, // + inv_h0, inv_h1, inv_h2, // + inv_v0, inv_v1, inv_v2, // + half_width_for_2to1, half_height_for_2to1, // scratch_buffer_2k.ptr, &upfuncs, conv3func); } diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index f71106c7..a4789b45 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -153,6 +153,7 @@ var Consts = [...]struct { // ---- {t.IDU32, "1", "QUIRK_IGNORE_CHECKSUM"}, + {t.IDU32, "2", "QUIRK_QUALITY"}, // ---- @@ -691,8 +692,10 @@ var funcsOther = [...]string{ "pixel_swizzler.swizzle_ycck!(" + "dst: ptr pixel_buffer," + "dst_palette: slice u8," + - "width: u32[..= 0xFFFF]," + - "height: u32[..= 0xFFFF]," + + "x_min_incl: u32[..= 0xFFFF]," + + "x_max_excl: u32[..= 0xFFFF]," + + "y_min_incl: u32[..= 0xFFFF]," + + "y_max_excl: u32[..= 0xFFFF]," + "src0: slice u8," + "src1: slice u8," + "src2: slice u8," + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 0433ec4b..de9d5d33 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -949,6 +949,8 @@ typedef struct wuffs_base__transform__output__struct { #define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1 +#define WUFFS_BASE__QUIRK_QUALITY 2 + // -------- // Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a @@ -2014,6 +2016,20 @@ WUFFS_BASE__MAYBE_STATIC int32_t // wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data, bool prefix_closed); +// ---------------- Quirk Values + +// These constants are the value half of a key-value pair, where the key is +// WUFFS_BASE__QUIRK_QUALITY. +// +// In the Wuffs API, set_quirk takes a u64 value. These macro definitions are +// likewise unsigned values (uint64_t) but for this particular key, they are +// best interpreted as signed values (int64_t). "Lower-than-default quality" +// and "higher-than-default quality", as signed values, are -1 and +1. +// +// See doc/note/quirks.md for some more discussion about trade-offs. +#define WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY UINT64_MAX +#define WUFFS_BASE__QUIRK_QUALITY__VALUE__HIGHER_QUALITY ((uint64_t)1) + // ---------------- Ranges and Rects // See https://github.com/google/wuffs/blob/main/doc/note/ranges-and-rects.md @@ -9891,6 +9907,11 @@ struct wuffs_jpeg__decoder__struct { uint32_t f_bitstream_wi; bool f_bitstream_is_closed; bool f_expect_multiple_scans; + bool f_use_lower_quality; + bool f_swizzle_immediately; + wuffs_base__status f_swizzle_immediately_status; + uint32_t f_swizzle_immediately_b_offsets[10]; + uint32_t f_swizzle_immediately_c_offsets[5]; uint32_t f_bitstream_padding; uint16_t f_quant_tables[4][64]; uint16_t f_saved_quant_tables[4][64]; @@ -9926,6 +9947,7 @@ struct wuffs_jpeg__decoder__struct { uint32_t p_skip_past_the_next_restart_marker; uint32_t (*choosy_decode_mcu)( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -9934,6 +9956,7 @@ struct wuffs_jpeg__decoder__struct { struct { uint8_t f_bitstream_buffer[2048]; uint16_t f_mcu_blocks[10][64]; + uint8_t f_swizzle_immediately_buffer[640]; uint8_t f_swizzle_ycck_scratch_buffer_2k[2048]; uint8_t f_dht_temp_counts[16]; uint8_t f_dht_temp_bit_lengths[256]; @@ -16592,8 +16615,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck( const wuffs_base__pixel_swizzler* p, wuffs_base__pixel_buffer* dst, wuffs_base__slice_u8 dst_palette, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src2, @@ -28528,8 +28553,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( static void // wuffs_private_impl__swizzle_ycck__general__triangle_filter( wuffs_base__pixel_buffer* dst, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, const uint8_t* src_ptr0, const uint8_t* src_ptr1, const uint8_t* src_ptr2, @@ -28551,6 +28578,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( uint8_t* scratch_buffer_2k_ptr, wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) { + if ((x_min_incl != 0) || (y_min_incl != 0)) { + return; + } + wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = @@ -28563,7 +28594,7 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( // First row. uint32_t h1v2_bias = 1u; wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( - dst, width, 0u, // + dst, x_max_excl, 0u, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, // stride0, stride1, stride2, stride3, // inv_h0, inv_h1, inv_h2, inv_h3, // @@ -28575,10 +28606,10 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( h1v2_bias = 2u; // Middle rows. - bool last_row = height == 2u * half_height_for_2to1; - uint32_t y_max_excl = last_row ? (height - 1u) : height; + bool last_row = y_max_excl == 2u * half_height_for_2to1; + uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; uint32_t y; - for (y = 1u; y < y_max_excl; y++) { + for (y = 1u; y < middle_y_max_excl; y++) { const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_minor = (inv_v0 != 2u) @@ -28605,11 +28636,11 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( uint32_t total_src_len3 = 0u; uint32_t x = 0u; - while (x < width) { + while (x < x_max_excl) { bool first_column = x == 0u; uint32_t end = x + 480u; - if (end > width) { - end = width; + if (end > x_max_excl) { + end = x_max_excl; } uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; @@ -28665,9 +28696,9 @@ wuffs_private_impl__swizzle_ycck__general__triangle_filter( } // Last row. - if (y_max_excl != height) { + if (middle_y_max_excl != y_max_excl) { wuffs_private_impl__swizzle_ycck__general__triangle_filter_edge_row( - dst, width, height - 1u, // + dst, x_max_excl, middle_y_max_excl, // src_ptr0, src_ptr1, src_ptr2, src_ptr3, // stride0, stride1, stride2, stride3, // inv_h0, inv_h1, inv_h2, inv_h3, // @@ -28763,8 +28794,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( static void // wuffs_private_impl__swizzle_ycc__general__triangle_filter( wuffs_base__pixel_buffer* dst, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, const uint8_t* src_ptr0, const uint8_t* src_ptr1, const uint8_t* src_ptr2, @@ -28782,6 +28815,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( uint8_t* scratch_buffer_2k_ptr, wuffs_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4], wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) { + if ((x_min_incl != 0) || (y_min_incl != 0)) { + return; + } + wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 = (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u]; wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 = @@ -28792,7 +28829,7 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( // First row. uint32_t h1v2_bias = 1u; wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( - dst, width, 0u, // + dst, x_max_excl, 0u, // src_ptr0, src_ptr1, src_ptr2, // stride0, stride1, stride2, // inv_h0, inv_h1, inv_h2, // @@ -28804,10 +28841,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( h1v2_bias = 2u; // Middle rows. - bool last_row = height == 2u * half_height_for_2to1; - uint32_t y_max_excl = last_row ? (height - 1u) : height; + bool last_row = y_max_excl == 2u * half_height_for_2to1; + uint32_t middle_y_max_excl = last_row ? (y_max_excl - 1u) : y_max_excl; uint32_t y; - for (y = 1u; y < y_max_excl; y++) { + for (y = 1u; y < middle_y_max_excl; y++) { const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); const uint8_t* src0_minor = (inv_v0 != 2u) @@ -28828,11 +28865,11 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( uint32_t total_src_len2 = 0u; uint32_t x = 0u; - while (x < width) { + while (x < x_max_excl) { bool first_column = x == 0u; uint32_t end = x + 672u; - if (end > width) { - end = width; + if (end > x_max_excl) { + end = x_max_excl; } uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; @@ -28877,16 +28914,16 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( } // Last row. - if (y_max_excl != height) { + if (middle_y_max_excl != y_max_excl) { wuffs_private_impl__swizzle_ycc__general__triangle_filter_edge_row( - dst, width, height - 1u, // - src_ptr0, src_ptr1, src_ptr2, // - stride0, stride1, stride2, // - inv_h0, inv_h1, inv_h2, // - inv_v0, inv_v1, inv_v2, // - half_width_for_2to1, // - h1v2_bias, // - scratch_buffer_2k_ptr, // + dst, x_max_excl, middle_y_max_excl, // + src_ptr0, src_ptr1, src_ptr2, // + stride0, stride1, stride2, // + inv_h0, inv_h1, inv_h2, // + inv_v0, inv_v1, inv_v2, // + half_width_for_2to1, // + h1v2_bias, // + scratch_buffer_2k_ptr, // upfunc0, upfunc1, upfunc2, conv3func); } } @@ -28894,8 +28931,10 @@ wuffs_private_impl__swizzle_ycc__general__triangle_filter( static void // wuffs_private_impl__swizzle_ycc__general__box_filter( wuffs_base__pixel_buffer* dst, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, const uint8_t* src_ptr0, const uint8_t* src_ptr1, const uint8_t* src_ptr2, @@ -28921,41 +28960,44 @@ wuffs_private_impl__swizzle_ycc__general__box_filter( (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u]; uint32_t y; - for (y = 0u; y < height; y++) { - const uint8_t* src0_major = src_ptr0 + ((y / inv_v0) * (size_t)stride0); - const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1); - const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2); + for (y = y_min_incl; y < y_max_excl; y++) { + const uint8_t* src0_major = + src_ptr0 + (((y - y_min_incl) / inv_v0) * (size_t)stride0); + const uint8_t* src1_major = + src_ptr1 + (((y - y_min_incl) / inv_v1) * (size_t)stride1); + const uint8_t* src2_major = + src_ptr2 + (((y - y_min_incl) / inv_v2) * (size_t)stride2); - uint32_t x = 0u; - while (x < width) { + uint32_t x = x_min_incl; + while (x < x_max_excl) { uint32_t end = x + 672u; - if (end > width) { - end = width; + if (end > x_max_excl) { + end = x_max_excl; } uint32_t src_len0 = ((end - x) + inv_h0 - 1u) / inv_h0; uint32_t src_len1 = ((end - x) + inv_h1 - 1u) / inv_h1; uint32_t src_len2 = ((end - x) + inv_h2 - 1u) / inv_h2; - const uint8_t* up0 = (*upfunc0)( // - scratch_buffer_2k_ptr + (0u * 672u), // - src0_major + (x / inv_h0), // - src0_major + (x / inv_h0), // - src_len0, // + const uint8_t* up0 = (*upfunc0)( // + scratch_buffer_2k_ptr + (0u * 672u), // + src0_major + ((x - x_min_incl) / inv_h0), // + src0_major + ((x - x_min_incl) / inv_h0), // + src_len0, // 0u, false, false); - const uint8_t* up1 = (*upfunc1)( // - scratch_buffer_2k_ptr + (1u * 672u), // - src1_major + (x / inv_h1), // - src1_major + (x / inv_h1), // - src_len1, // + const uint8_t* up1 = (*upfunc1)( // + scratch_buffer_2k_ptr + (1u * 672u), // + src1_major + ((x - x_min_incl) / inv_h1), // + src1_major + ((x - x_min_incl) / inv_h1), // + src_len1, // 0u, false, false); - const uint8_t* up2 = (*upfunc2)( // - scratch_buffer_2k_ptr + (2u * 672u), // - src2_major + (x / inv_h2), // - src2_major + (x / inv_h2), // - src_len2, // + const uint8_t* up2 = (*upfunc2)( // + scratch_buffer_2k_ptr + (2u * 672u), // + src2_major + ((x - x_min_incl) / inv_h2), // + src2_major + ((x - x_min_incl) / inv_h2), // + src_len2, // 0u, false, false); (*conv3func)(dst, x, end, y, up0, up1, up2); @@ -28988,8 +29030,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck( const wuffs_base__pixel_swizzler* p, wuffs_base__pixel_buffer* dst, wuffs_base__slice_u8 dst_palette, - uint32_t width, - uint32_t height, + uint32_t x_min_incl, + uint32_t x_max_excl, + uint32_t y_min_incl, + uint32_t y_max_excl, wuffs_base__slice_u8 src0, wuffs_base__slice_u8 src1, wuffs_base__slice_u8 src2, @@ -29019,13 +29063,19 @@ wuffs_base__pixel_swizzler__swizzle_ycck( wuffs_base__slice_u8 scratch_buffer_2k) { if (!p) { return wuffs_base__make_status(wuffs_base__error__bad_receiver); - } else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || // - (4u <= ((unsigned int)h0 - 1u)) || // - (4u <= ((unsigned int)h1 - 1u)) || // - (4u <= ((unsigned int)h2 - 1u)) || // - (4u <= ((unsigned int)v0 - 1u)) || // - (4u <= ((unsigned int)v1 - 1u)) || // - (4u <= ((unsigned int)v2 - 1u)) || // + } else if (!dst || // + (x_min_incl > x_max_excl) || // + (x_max_excl > 0xFFFFu) || // + (y_min_incl > y_max_excl) || // + (y_max_excl > 0xFFFFu) || // + (4u <= ((unsigned int)h0 - 1u)) || // + (4u <= ((unsigned int)h1 - 1u)) || // + (4u <= ((unsigned int)h2 - 1u)) || // + (4u <= ((unsigned int)v0 - 1u)) || // + (4u <= ((unsigned int)v1 - 1u)) || // + (4u <= ((unsigned int)v2 - 1u)) || // + (triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) || + (!triangle_filter_for_2to1 && ((h3 | v3) > 0u)) || (scratch_buffer_2k.len < 2048u)) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } @@ -29052,21 +29102,69 @@ wuffs_base__pixel_swizzler__swizzle_ycck( uint32_t inv_v2 = max_incl_v / v2; uint32_t inv_v3 = v3 ? (max_incl_v / v3) : 0u; - uint32_t half_width_for_2to1 = (width + 1u) / 2u; - uint32_t half_height_for_2to1 = (height + 1u) / 2u; + if (x_min_incl != 0) { + if ((x_min_incl % inv_h0) || (x_min_incl % inv_h1) || + (x_min_incl % inv_h2) || (inv_h3 && (x_min_incl % inv_h3))) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + } + if (y_min_incl != 0) { + if ((y_min_incl % inv_v0) || (y_min_incl % inv_v1) || + (y_min_incl % inv_v2) || (inv_v3 && (y_min_incl % inv_v3))) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + } - width = wuffs_private_impl__u32__min_of_5( // - width, // - width0 * inv_h0, // - width1 * inv_h1, // - width2 * inv_h2, // - wuffs_base__pixel_config__width(&dst->pixcfg)); - height = wuffs_private_impl__u32__min_of_5( // - height, // - height0 * inv_v0, // - height1 * inv_v1, // - height2 * inv_v2, // - wuffs_base__pixel_config__height(&dst->pixcfg)); + uint32_t half_width_for_2to1 = ((x_max_excl - x_min_incl) + 1u) / 2u; + if (inv_h0 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width0); + } + if (inv_h1 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width1); + } + if (inv_h2 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width2); + } + if (inv_h3 == 2) { + half_width_for_2to1 = wuffs_base__u32__min(half_width_for_2to1, width3); + } + + uint32_t half_height_for_2to1 = ((y_max_excl - y_min_incl) + 1u) / 2u; + if (inv_v0 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height0); + } + if (inv_v1 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height1); + } + if (inv_v2 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height2); + } + if (inv_v3 == 2) { + half_height_for_2to1 = wuffs_base__u32__min(half_height_for_2to1, height3); + } + + x_max_excl = wuffs_base__u32__min( // + wuffs_base__pixel_config__width(&dst->pixcfg), // + x_min_incl + wuffs_private_impl__u32__min_of_5( // + x_max_excl - x_min_incl, // + width0 * inv_h0, // + width1 * inv_h1, // + width2 * inv_h2, // + inv_h3 ? (width3 * inv_h3) : 0xFFFFFFFF)); + y_max_excl = wuffs_base__u32__min( // + wuffs_base__pixel_config__height(&dst->pixcfg), // + y_min_incl + wuffs_private_impl__u32__min_of_5( // + y_max_excl - y_min_incl, // + height0 * inv_v0, // + height1 * inv_v1, // + height2 * inv_v2, // + inv_v3 ? (height3 * inv_v3) : 0xFFFFFFFF)); + + if ((x_min_incl >= x_max_excl) || (y_min_incl >= y_max_excl)) { + return wuffs_base__make_status(NULL); + } + uint32_t width = x_max_excl - x_min_incl; + uint32_t height = y_max_excl - y_min_incl; if (((h0 * inv_h0) != max_incl_h) || // ((h1 * inv_h1) != max_incl_h) || // @@ -29167,10 +29265,6 @@ wuffs_base__pixel_swizzler__swizzle_ycck( // ---- - if ((width <= 0u) || (height <= 0u)) { - return wuffs_base__make_status(NULL); - } - wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL; if (is_rgb_or_cmyk) { @@ -29206,8 +29300,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck( } void (*func)(wuffs_base__pixel_buffer * dst, // - uint32_t width, // - uint32_t height, // + uint32_t x_min_incl, // + uint32_t x_max_excl, // + uint32_t y_min_incl, // + uint32_t y_max_excl, // const uint8_t* src_ptr0, // const uint8_t* src_ptr1, // const uint8_t* src_ptr2, // @@ -29268,7 +29364,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck( is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general : &wuffs_private_impl__swizzle_ycck__convert_4_general; wuffs_private_impl__swizzle_ycck__general__triangle_filter( // - dst, width, height, // + dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // src0.ptr, src1.ptr, src2.ptr, src3.ptr, // stride0, stride1, stride2, stride3, // inv_h0, inv_h1, inv_h2, inv_h3, // @@ -29277,13 +29373,13 @@ wuffs_base__pixel_swizzler__swizzle_ycck( scratch_buffer_2k.ptr, &upfuncs, conv4func); } else { - (*func)( // - dst, width, height, // - src0.ptr, src1.ptr, src2.ptr, // - stride0, stride1, stride2, // - inv_h0, inv_h1, inv_h2, // - inv_v0, inv_v1, inv_v2, // - half_width_for_2to1, half_height_for_2to1, // + (*func)( // + dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, // + src0.ptr, src1.ptr, src2.ptr, // + stride0, stride1, stride2, // + inv_h0, inv_h1, inv_h2, // + inv_v0, inv_v1, inv_v2, // + half_width_for_2to1, half_height_for_2to1, // scratch_buffer_2k.ptr, &upfuncs, conv3func); } @@ -44051,6 +44147,7 @@ WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__slice_u8 a_workbuf); @@ -44133,14 +44230,23 @@ static wuffs_base__status wuffs_jpeg__decoder__swizzle_gray( wuffs_jpeg__decoder* self, wuffs_base__pixel_buffer* a_dst, - wuffs_base__slice_u8 a_workbuf); + wuffs_base__slice_u8 a_workbuf, + uint32_t a_x0, + uint32_t a_x1, + uint32_t a_y0, + uint32_t a_y1, + uint64_t a_stride); WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_jpeg__decoder__swizzle_colorful( wuffs_jpeg__decoder* self, wuffs_base__pixel_buffer* a_dst, - wuffs_base__slice_u8 a_workbuf); + wuffs_base__slice_u8 a_workbuf, + uint32_t a_x0, + uint32_t a_x1, + uint32_t a_y0, + uint32_t a_y1); WUFFS_BASE__GENERATED_C_CODE static bool @@ -44161,6 +44267,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -44169,6 +44276,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu__choosy_default( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -44177,6 +44285,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -44185,6 +44294,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -44193,6 +44303,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -44201,6 +44312,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my); @@ -45844,6 +45956,11 @@ wuffs_jpeg__decoder__get_quirk( return 0; } + if (a_key == 2u) { + if (self->private_impl.f_use_lower_quality) { + return 18446744073709551615u; + } + } return 0u; } @@ -45865,6 +45982,10 @@ wuffs_jpeg__decoder__set_quirk( : wuffs_base__error__initialize_not_called); } + if (a_key == 2u) { + self->private_impl.f_use_lower_quality = (a_value >= 9223372036854775808u); + return wuffs_base__make_status(NULL); + } return wuffs_base__make_status(wuffs_base__error__unsupported_option); } @@ -47151,14 +47272,27 @@ wuffs_jpeg__decoder__decode_frame( if ((v_ddf_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) { v_ddf_status = wuffs_base__make_status(wuffs_jpeg__error__truncated_input); } - if (wuffs_base__status__is_error(&v_ddf_status) || (v_scan_count < self->private_impl.f_scan_count)) { + if ( ! self->private_impl.f_swizzle_immediately && (wuffs_base__status__is_error(&v_ddf_status) || (v_scan_count < self->private_impl.f_scan_count))) { if (self->private_impl.f_sof_marker >= 194u) { wuffs_jpeg__decoder__apply_progressive_idct(self, a_workbuf); } if (self->private_impl.f_num_components == 1u) { - v_swizzle_status = wuffs_jpeg__decoder__swizzle_gray(self, a_dst, a_workbuf); + v_swizzle_status = wuffs_jpeg__decoder__swizzle_gray(self, + a_dst, + a_workbuf, + 0u, + 4294967295u, + 0u, + 4294967295u, + ((uint64_t)(self->private_impl.f_components_workbuf_widths[0u]))); } else { - v_swizzle_status = wuffs_jpeg__decoder__swizzle_colorful(self, a_dst, a_workbuf); + v_swizzle_status = wuffs_jpeg__decoder__swizzle_colorful(self, + a_dst, + a_workbuf, + 0u, + 4294967295u, + 0u, + 4294967295u); } if (wuffs_base__status__is_error(&v_ddf_status)) { status = v_ddf_status; @@ -47263,9 +47397,14 @@ wuffs_jpeg__decoder__do_decode_frame( } goto ok; } + self->private_impl.f_swizzle_immediately = false; if (self->private_impl.f_components_workbuf_offsets[8u] > ((uint64_t)(a_workbuf.len))) { - status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); - goto exit; + if (self->private_impl.f_sof_marker >= 194u) { + status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); + goto exit; + } + self->private_impl.f_swizzle_immediately = (self->private_impl.f_use_lower_quality && (self->private_impl.f_num_components < 4u)); + self->private_impl.f_swizzle_immediately_status = wuffs_base__make_status(NULL); } else if (self->private_impl.f_components_workbuf_offsets[4u] < self->private_impl.f_components_workbuf_offsets[8u]) { wuffs_private_impl__bulk_memset(a_workbuf.ptr + self->private_impl.f_components_workbuf_offsets[4u], (self->private_impl.f_components_workbuf_offsets[8u] - self->private_impl.f_components_workbuf_offsets[4u]), 0u); } @@ -47378,7 +47517,7 @@ wuffs_jpeg__decoder__do_decode_frame( a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); - status = wuffs_jpeg__decoder__decode_sos(self, a_src, a_workbuf); + status = wuffs_jpeg__decoder__decode_sos(self, a_dst, a_src, a_workbuf); if (a_src) { iop_a_src = a_src->data.ptr + a_src->meta.ri; } @@ -47741,6 +47880,7 @@ WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__slice_u8 a_workbuf) { wuffs_base__status status = wuffs_base__make_status(NULL); @@ -47793,12 +47933,26 @@ wuffs_jpeg__decoder__decode_sos( wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf); } while (true) { - v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self, a_workbuf, v_mx, v_my); + v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self, + a_dst, + a_workbuf, + v_mx, + v_my); if (v_decode_mcu_result == 0u) { break; - } else if (v_decode_mcu_result != 1u) { + } else if (v_decode_mcu_result == 1u) { + } else if (v_decode_mcu_result == 2u) { status = wuffs_base__make_status(wuffs_jpeg__error__internal_error_inconsistent_decoder_state); goto exit; + } else { + status = self->private_impl.f_swizzle_immediately_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; } while (true) { v_bitstream_length = ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri)); @@ -48239,6 +48393,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields( uint32_t v_b = 0; uint32_t v_bx_offset = 0; uint32_t v_by_offset = 0; + uint32_t v_sibo = 0; uint8_t v_ssel = 0; uint8_t v_csel = 0; @@ -48251,6 +48406,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields( v_h = ((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])); v_v = ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]])); v_hv = (((uint32_t)(self->private_impl.f_components_h[self->private_impl.f_scan_comps_cselector[v_i]])) * ((uint32_t)(self->private_impl.f_components_v[self->private_impl.f_scan_comps_cselector[v_i]]))); + self->private_impl.f_swizzle_immediately_c_offsets[v_i] = ((uint32_t)(64u * v_total_hv)); v_total_hv += v_hv; while (v_hv > 0u) { self->private_impl.f_scan_comps_bx_offset[(v_b & 15u)] = ((uint8_t)((v_bx_offset & 3u))); @@ -48273,6 +48429,7 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields( return true; } self->private_impl.f_mcu_num_blocks = v_total_hv; + self->private_impl.f_swizzle_immediately_c_offsets[self->private_impl.f_scan_num_components] = ((uint32_t)(64u * v_total_hv)); v_b = 0u; while (v_b < self->private_impl.f_mcu_num_blocks) { v_ssel = self->private_impl.f_mcu_blocks_sselector[v_b]; @@ -48282,6 +48439,8 @@ wuffs_jpeg__decoder__calculate_multiple_component_scan_fields( self->private_impl.f_mcu_blocks_my_mul[v_b] = (8u * ((uint32_t)(self->private_impl.f_components_v[v_csel])) * self->private_impl.f_components_workbuf_widths[v_csel]); self->private_impl.f_mcu_blocks_dc_hselector[v_b] = ((uint8_t)(0u | self->private_impl.f_scan_comps_td[v_ssel])); self->private_impl.f_mcu_blocks_ac_hselector[v_b] = ((uint8_t)(4u | self->private_impl.f_scan_comps_ta[v_ssel])); + v_sibo = ((uint32_t)(self->private_impl.f_swizzle_immediately_c_offsets[v_csel] + ((8u * ((uint32_t)(self->private_impl.f_scan_comps_bx_offset[v_b]))) + (64u * ((uint32_t)(self->private_impl.f_scan_comps_by_offset[v_b])) * ((uint32_t)(self->private_impl.f_components_h[v_csel])))))); + self->private_impl.f_swizzle_immediately_b_offsets[v_b] = wuffs_base__u32__min(v_sibo, 576u); v_b += 1u; } self->private_impl.f_scan_width_in_mcus = self->private_impl.f_width_in_mcus; @@ -48617,15 +48776,21 @@ static wuffs_base__status wuffs_jpeg__decoder__swizzle_gray( wuffs_jpeg__decoder* self, wuffs_base__pixel_buffer* a_dst, - wuffs_base__slice_u8 a_workbuf) { + wuffs_base__slice_u8 a_workbuf, + uint32_t a_x0, + uint32_t a_x1, + uint32_t a_y0, + uint32_t a_y1, + uint64_t a_stride) { wuffs_base__pixel_format v_dst_pixfmt = {0}; uint32_t v_dst_bits_per_pixel = 0; uint32_t v_dst_bytes_per_pixel = 0; - uint64_t v_dst_length = 0; + uint64_t v_x0 = 0; + uint64_t v_x1 = 0; wuffs_base__table_u8 v_tab = {0}; wuffs_base__slice_u8 v_dst = {0}; uint32_t v_y = 0; - uint64_t v_stride = 0; + uint32_t v_y1 = 0; v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); @@ -48633,18 +48798,24 @@ wuffs_jpeg__decoder__swizzle_gray( return wuffs_base__make_status(wuffs_base__error__unsupported_option); } v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u); - v_dst_length = ((uint64_t)((v_dst_bytes_per_pixel * self->private_impl.f_width))); + v_x0 = ((uint64_t)((v_dst_bytes_per_pixel * wuffs_base__u32__min(a_x0, self->private_impl.f_width)))); + v_x1 = ((uint64_t)((v_dst_bytes_per_pixel * wuffs_base__u32__min(a_x1, self->private_impl.f_width)))); v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); - v_y = 0u; - while (v_y < self->private_impl.f_height) { + v_y = a_y0; + v_y1 = wuffs_base__u32__min(a_y1, self->private_impl.f_height); + while (v_y < v_y1) { v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); - if (v_dst_length < ((uint64_t)(v_dst.len))) { - v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_length); + if (v_x1 < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_x1); + } + if (v_x0 < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_x0); + } else { + v_dst = wuffs_base__utility__empty_slice_u8(); } wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), a_workbuf); - v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[0u])); - if (v_stride <= ((uint64_t)(a_workbuf.len))) { - a_workbuf = wuffs_base__slice_u8__subslice_i(a_workbuf, v_stride); + if (a_stride <= ((uint64_t)(a_workbuf.len))) { + a_workbuf = wuffs_base__slice_u8__subslice_i(a_workbuf, a_stride); } else { a_workbuf = wuffs_base__utility__empty_slice_u8(); } @@ -48660,54 +48831,109 @@ static wuffs_base__status wuffs_jpeg__decoder__swizzle_colorful( wuffs_jpeg__decoder* self, wuffs_base__pixel_buffer* a_dst, - wuffs_base__slice_u8 a_workbuf) { + wuffs_base__slice_u8 a_workbuf, + uint32_t a_x0, + uint32_t a_x1, + uint32_t a_y0, + uint32_t a_y1) { + uint64_t v_i = 0; + uint64_t v_j = 0; wuffs_base__slice_u8 v_src0 = {0}; wuffs_base__slice_u8 v_src1 = {0}; wuffs_base__slice_u8 v_src2 = {0}; wuffs_base__slice_u8 v_src3 = {0}; + uint32_t v_width0 = 0; + uint32_t v_width1 = 0; + uint32_t v_width2 = 0; + uint32_t v_width3 = 0; + uint32_t v_height0 = 0; + uint32_t v_height1 = 0; + uint32_t v_height2 = 0; + uint32_t v_height3 = 0; wuffs_base__status v_status = wuffs_base__make_status(NULL); - if ((self->private_impl.f_components_workbuf_offsets[0u] <= self->private_impl.f_components_workbuf_offsets[1u]) && (self->private_impl.f_components_workbuf_offsets[1u] <= ((uint64_t)(a_workbuf.len)))) { - v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf, - self->private_impl.f_components_workbuf_offsets[0u], - self->private_impl.f_components_workbuf_offsets[1u]); - } - if ((self->private_impl.f_components_workbuf_offsets[1u] <= self->private_impl.f_components_workbuf_offsets[2u]) && (self->private_impl.f_components_workbuf_offsets[2u] <= ((uint64_t)(a_workbuf.len)))) { - v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf, - self->private_impl.f_components_workbuf_offsets[1u], - self->private_impl.f_components_workbuf_offsets[2u]); - } - if ((self->private_impl.f_components_workbuf_offsets[2u] <= self->private_impl.f_components_workbuf_offsets[3u]) && (self->private_impl.f_components_workbuf_offsets[3u] <= ((uint64_t)(a_workbuf.len)))) { - v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf, - self->private_impl.f_components_workbuf_offsets[2u], - self->private_impl.f_components_workbuf_offsets[3u]); - } - if ((self->private_impl.f_components_workbuf_offsets[3u] <= self->private_impl.f_components_workbuf_offsets[4u]) && (self->private_impl.f_components_workbuf_offsets[4u] <= ((uint64_t)(a_workbuf.len)))) { - v_src3 = wuffs_base__slice_u8__subslice_ij(a_workbuf, - self->private_impl.f_components_workbuf_offsets[3u], - self->private_impl.f_components_workbuf_offsets[4u]); + if (self->private_impl.f_swizzle_immediately) { + v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[0u])); + v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[1u])); + if ((v_i <= v_j) && (v_j <= 640u)) { + v_src0 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j); + v_width0 = (8u * ((uint32_t)(self->private_impl.f_components_h[0u]))); + v_height0 = (8u * ((uint32_t)(self->private_impl.f_components_v[0u]))); + } + v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[1u])); + v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[2u])); + if ((v_i <= v_j) && (v_j <= 640u)) { + v_src1 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j); + v_width1 = (8u * ((uint32_t)(self->private_impl.f_components_h[1u]))); + v_height1 = (8u * ((uint32_t)(self->private_impl.f_components_v[1u]))); + } + v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[2u])); + v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[3u])); + if ((v_i <= v_j) && (v_j <= 640u)) { + v_src2 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j); + v_width2 = (8u * ((uint32_t)(self->private_impl.f_components_h[2u]))); + v_height2 = (8u * ((uint32_t)(self->private_impl.f_components_v[2u]))); + } + v_i = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[3u])); + v_j = ((uint64_t)(self->private_impl.f_swizzle_immediately_c_offsets[4u])); + if ((v_i <= v_j) && (v_j <= 640u)) { + v_src3 = wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, v_i, v_j); + v_width3 = (8u * ((uint32_t)(self->private_impl.f_components_h[3u]))); + v_height3 = (8u * ((uint32_t)(self->private_impl.f_components_v[3u]))); + } + } else { + if ((self->private_impl.f_components_workbuf_offsets[0u] <= self->private_impl.f_components_workbuf_offsets[1u]) && (self->private_impl.f_components_workbuf_offsets[1u] <= ((uint64_t)(a_workbuf.len)))) { + v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf, + self->private_impl.f_components_workbuf_offsets[0u], + self->private_impl.f_components_workbuf_offsets[1u]); + v_width0 = self->private_impl.f_components_workbuf_widths[0u]; + v_height0 = self->private_impl.f_components_workbuf_heights[0u]; + } + if ((self->private_impl.f_components_workbuf_offsets[1u] <= self->private_impl.f_components_workbuf_offsets[2u]) && (self->private_impl.f_components_workbuf_offsets[2u] <= ((uint64_t)(a_workbuf.len)))) { + v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf, + self->private_impl.f_components_workbuf_offsets[1u], + self->private_impl.f_components_workbuf_offsets[2u]); + v_width1 = self->private_impl.f_components_workbuf_widths[1u]; + v_height1 = self->private_impl.f_components_workbuf_heights[1u]; + } + if ((self->private_impl.f_components_workbuf_offsets[2u] <= self->private_impl.f_components_workbuf_offsets[3u]) && (self->private_impl.f_components_workbuf_offsets[3u] <= ((uint64_t)(a_workbuf.len)))) { + v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf, + self->private_impl.f_components_workbuf_offsets[2u], + self->private_impl.f_components_workbuf_offsets[3u]); + v_width2 = self->private_impl.f_components_workbuf_widths[2u]; + v_height2 = self->private_impl.f_components_workbuf_heights[2u]; + } + if ((self->private_impl.f_components_workbuf_offsets[3u] <= self->private_impl.f_components_workbuf_offsets[4u]) && (self->private_impl.f_components_workbuf_offsets[4u] <= ((uint64_t)(a_workbuf.len)))) { + v_src3 = wuffs_base__slice_u8__subslice_ij(a_workbuf, + self->private_impl.f_components_workbuf_offsets[3u], + self->private_impl.f_components_workbuf_offsets[4u]); + v_width3 = self->private_impl.f_components_workbuf_widths[3u]; + v_height3 = self->private_impl.f_components_workbuf_heights[3u]; + } } v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler, a_dst, wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)), - self->private_impl.f_width, - self->private_impl.f_height, + (a_x0 & 65535u), + wuffs_base__u32__min(a_x1, self->private_impl.f_width), + (a_y0 & 65535u), + wuffs_base__u32__min(a_y1, self->private_impl.f_height), v_src0, v_src1, v_src2, v_src3, - self->private_impl.f_components_workbuf_widths[0u], - self->private_impl.f_components_workbuf_widths[1u], - self->private_impl.f_components_workbuf_widths[2u], - self->private_impl.f_components_workbuf_widths[3u], - self->private_impl.f_components_workbuf_heights[0u], - self->private_impl.f_components_workbuf_heights[1u], - self->private_impl.f_components_workbuf_heights[2u], - self->private_impl.f_components_workbuf_heights[3u], - self->private_impl.f_components_workbuf_widths[0u], - self->private_impl.f_components_workbuf_widths[1u], - self->private_impl.f_components_workbuf_widths[2u], - self->private_impl.f_components_workbuf_widths[3u], + v_width0, + v_width1, + v_width2, + v_width3, + v_height0, + v_height1, + v_height2, + v_height3, + v_width0, + v_width1, + v_width2, + v_width3, self->private_impl.f_components_h[0u], self->private_impl.f_components_h[1u], self->private_impl.f_components_h[2u], @@ -48717,7 +48943,7 @@ wuffs_jpeg__decoder__swizzle_colorful( self->private_impl.f_components_v[2u], self->private_impl.f_components_v[3u], self->private_impl.f_is_rgb_or_cmyk, - true, + ! (self->private_impl.f_use_lower_quality && (self->private_impl.f_num_components < 4u)), wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048)); return wuffs_private_impl__status__ensure_not_a_suspension(v_status); } @@ -48928,6 +49154,9 @@ wuffs_jpeg__decoder__workbuf_len( return wuffs_base__utility__empty_range_ii_u64(); } + if (self->private_impl.f_use_lower_quality && (self->private_impl.f_num_components < 4u) && (self->private_impl.f_sof_marker < 194u)) { + return wuffs_base__utility__make_range_ii_u64(0u, self->private_impl.f_components_workbuf_offsets[8u]); + } return wuffs_base__utility__make_range_ii_u64(self->private_impl.f_components_workbuf_offsets[8u], self->private_impl.f_components_workbuf_offsets[8u]); } @@ -49564,16 +49793,18 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my) { - return (*self->private_impl.choosy_decode_mcu)(self, a_workbuf, a_mx, a_my); + return (*self->private_impl.choosy_decode_mcu)(self, a_dst, a_workbuf, a_mx, a_my); } WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu__choosy_default( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my) { @@ -49773,11 +50004,47 @@ wuffs_jpeg__decoder__decode_mcu__choosy_default( if (self->private_impl.f_test_only_interrupt_decode_mcu) { goto label__goto_done__break; } - v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]]; - v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel])); - v_offset = (self->private_impl.f_mcu_blocks_offset[v_mcb] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[v_mcb])) * ((uint64_t)(a_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[v_mcb])) * ((uint64_t)(a_my)))); - if (v_offset <= ((uint64_t)(a_workbuf.len))) { - wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel]))); + if ( ! self->private_impl.f_swizzle_immediately) { + v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]]; + v_stride = ((uint64_t)(self->private_impl.f_components_workbuf_widths[v_csel])); + v_offset = (self->private_impl.f_mcu_blocks_offset[v_mcb] + (((uint64_t)(self->private_impl.f_mcu_blocks_mx_mul[v_mcb])) * ((uint64_t)(a_mx))) + (((uint64_t)(self->private_impl.f_mcu_blocks_my_mul[v_mcb])) * ((uint64_t)(a_my)))); + if (v_offset <= ((uint64_t)(a_workbuf.len))) { + wuffs_jpeg__decoder__decode_idct(self, wuffs_base__slice_u8__subslice_i(a_workbuf, v_offset), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel]))); + } + } else if (self->private_impl.f_num_components == 1u) { + wuffs_jpeg__decoder__decode_idct(self, wuffs_base__make_slice_u8(self->private_data.f_swizzle_immediately_buffer, 64), 8u, ((uint32_t)(self->private_impl.f_components_tq[v_csel]))); + self->private_impl.f_swizzle_immediately_status = wuffs_jpeg__decoder__swizzle_gray(self, + a_dst, + wuffs_base__make_slice_u8(self->private_data.f_swizzle_immediately_buffer, 64), + ((a_mx + 0u) * 8u), + ((a_mx + 1u) * 8u), + ((a_my + 0u) * 8u), + ((a_my + 1u) * 8u), + 8u); + if ( ! wuffs_base__status__is_ok(&self->private_impl.f_swizzle_immediately_status)) { + v_ret = 3u; + goto label__goto_done__break; + } + break; + } else { + v_csel = self->private_impl.f_scan_comps_cselector[self->private_impl.f_mcu_blocks_sselector[v_mcb]]; + v_stride = (8u * ((uint64_t)(self->private_impl.f_components_h[v_csel]))); + wuffs_jpeg__decoder__decode_idct(self, wuffs_base__make_slice_u8_ij(self->private_data.f_swizzle_immediately_buffer, self->private_impl.f_swizzle_immediately_b_offsets[v_mcb], 640), v_stride, ((uint32_t)(self->private_impl.f_components_tq[v_csel]))); + if (self->private_impl.f_mcu_current_block < self->private_impl.f_mcu_num_blocks) { + continue; + } + self->private_impl.f_swizzle_immediately_status = wuffs_jpeg__decoder__swizzle_colorful(self, + a_dst, + wuffs_base__utility__empty_slice_u8(), + ((a_mx + 0u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_h))), + ((a_mx + 1u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_h))), + ((a_my + 0u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_v))), + ((a_my + 1u) * 8u * ((uint32_t)(self->private_impl.f_max_incl_components_v)))); + if ( ! wuffs_base__status__is_ok(&self->private_impl.f_swizzle_immediately_status)) { + v_ret = 3u; + goto label__goto_done__break; + } + break; } } self->private_impl.f_mcu_current_block = 0u; @@ -49806,6 +50073,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_ac_high_bits( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my) { @@ -49973,6 +50241,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_ac_low_bit( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my) { @@ -50234,6 +50503,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_dc_high_bits( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my) { @@ -50374,6 +50644,7 @@ WUFFS_BASE__GENERATED_C_CODE static uint32_t wuffs_jpeg__decoder__decode_mcu_progressive_dc_low_bit( wuffs_jpeg__decoder* self, + wuffs_base__pixel_buffer* a_dst, wuffs_base__slice_u8 a_workbuf, uint32_t a_mx, uint32_t a_my) { @@ -77849,6 +78120,13 @@ redirect: // Apply quirks. for (size_t i = 0; i < quirks.len; i++) { + // TODO: don't special-case this. + if (quirks.ptr[i] == WUFFS_BASE__QUIRK_QUALITY) { + image_decoder->set_quirk( + WUFFS_BASE__QUIRK_QUALITY, + WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY); + continue; + } image_decoder->set_quirk(quirks.ptr[i], 1); } diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs index d6fa4ecf..bde62b06 100644 --- a/std/jpeg/decode_jpeg.wuffs +++ b/std/jpeg/decode_jpeg.wuffs @@ -281,6 +281,13 @@ pub struct decoder? implements base.image_decoder( expect_multiple_scans : base.bool, + use_lower_quality : base.bool, + + swizzle_immediately : base.bool, + swizzle_immediately_status : base.status, + swizzle_immediately_b_offsets : array[10] base.u32[..= 576], + swizzle_immediately_c_offsets : array[5] base.u32, + // bitstream_padding is the number (per restart) of implicit zeroes // remaining at the end of the bitstream. Its initial 12345 value is // arbitrary. @@ -314,6 +321,8 @@ pub struct decoder? implements base.image_decoder( // Decoding progressive JPEGs can use all of it. mcu_blocks : array[10] array[64] base.u16, + swizzle_immediately_buffer : array[640] base.u8, + swizzle_ycck_scratch_buffer_2k : array[2048] base.u8, // The dht_temp_etc fields are decode_dht temporary values. @@ -329,10 +338,45 @@ pub struct decoder? implements base.image_decoder( ) pub func decoder.get_quirk(key: base.u32) base.u64 { + if args.key == base.QUIRK_QUALITY { + if this.use_lower_quality { + return 0xFFFF_FFFF_FFFF_FFFF + } + } return 0 } +// If key is base.QUIRK_QUALITY then, when re-interpreting the value as a +// signed i64 value, a negative quirk value opts the decoder in to a slightly +// worse quality but leaner (less memory required) chroma upsampling algorithm. +// +// Negative (in i64 space) means >= 0x8000_0000_0000_0000 (in u64 space). +// +// Specifically, a negative quirk value uses a box filter. A non-negative quirk +// value (including the default value, zero) uses the same triangle filter that +// libjpeg-turbo also uses by default, which requires chroma upsampling on the +// edges of a MCU (Minimum Coded Unit) to remember adjacent MCU's values. +// +// Leaner means that for common (but not all) JPEG images, the range returned +// by decoder.workbuf_len can have a minimum value of zero, meaning that no +// work buffer memory needs to be allocated. "Common" includes sequential (not +// progressive) JPEGs that have either 1 component (gray) or 3 components (RGB +// or YCbCr). Decoding rarer JPEGs will still require a positive amount of work +// buffer memory. The exact amount required depends on factors like the JPEG +// image's width, height, component count and subsampling ratios. +// +// Regardless of the quirk value, as always, the workbuf_len method returns a +// range, whose min and max can be different. The caller is able to choose +// between providing the minimal amount of work buffer memory (for slightly +// slower decoding) or the maximal amount (for slightly faster decoding). +// +// Callers that never wish to allocate work buffer memory can simply reject +// these rarer JPEGs as unsupported. pub func decoder.set_quirk!(key: base.u32, value: base.u64) base.status { + if args.key == base.QUIRK_QUALITY { + this.use_lower_quality = args.value >= 0x8000_0000_0000_0000 + return ok + } return base."#unsupported option" } @@ -881,15 +925,29 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, ddf_status = "#truncated input" } - if ddf_status.is_error() or (scan_count < this.scan_count) { + if (not this.swizzle_immediately) and + (ddf_status.is_error() or (scan_count < this.scan_count)) { if this.sof_marker >= 0xC2 { this.apply_progressive_idct!(workbuf: args.workbuf) } if this.num_components == 1 { - swizzle_status = this.swizzle_gray!(dst: args.dst, workbuf: args.workbuf) + swizzle_status = this.swizzle_gray!( + dst: args.dst, + workbuf: args.workbuf, + x0: 0, + x1: 0xFFFF_FFFF, + y0: 0, + y1: 0xFFFF_FFFF, + stride: this.components_workbuf_widths[0] as base.u64) } else { - swizzle_status = this.swizzle_colorful!(dst: args.dst, workbuf: args.workbuf) + swizzle_status = this.swizzle_colorful!( + dst: args.dst, + workbuf: args.workbuf, + x0: 0, + x1: 0xFFFF_FFFF, + y0: 0, + y1: 0xFFFF_FFFF) } if ddf_status.is_error() { return ddf_status @@ -932,9 +990,14 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade // For progressive JPEGs, zero-initialize the saved pre-IDCT blocks. For // sequential JPEGs, this is a no-op, other than checking that args.workbuf - // is long enough. + // is long enough and setting this.swizzle_immediately. + this.swizzle_immediately = false if this.components_workbuf_offsets[8] > args.workbuf.length() { - return base."#bad workbuf length" + if this.sof_marker >= 0xC2 { + return base."#bad workbuf length" + } + this.swizzle_immediately = this.use_lower_quality and (this.num_components < 4) + this.swizzle_immediately_status = ok } else if this.components_workbuf_offsets[4] < this.components_workbuf_offsets[8] { args.workbuf[this.components_workbuf_offsets[4] .. this.components_workbuf_offsets[8]].bulk_memset!(byte_value: 0) } @@ -1009,7 +1072,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade break } else if marker == 0xDA { // SOS (Start Of Scan). - this.decode_sos?(src: args.src, workbuf: args.workbuf) + this.decode_sos?(dst: args.dst, src: args.src, workbuf: args.workbuf) continue } else if marker == 0xDB { // DQT (Define Quantization Table). @@ -1250,7 +1313,7 @@ pri func decoder.calculate_huff_tables!(tc4_th: base.u8[..= 7], total_count: bas return false } -pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) { +pri func decoder.decode_sos?(dst: ptr base.pixel_buffer, src: base.io_reader, workbuf: slice base.u8) { var my : base.u32 var mx : base.u32 @@ -1299,11 +1362,15 @@ pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) { inv my < 0x2000, inv mx < 0x2000, { - decode_mcu_result = this.decode_mcu!(workbuf: args.workbuf, mx: mx, my: my) + decode_mcu_result = this.decode_mcu!(dst: args.dst, workbuf: args.workbuf, mx: mx, my: my) if decode_mcu_result == 0 { break.decode_mcu - } else if decode_mcu_result <> 1 { + } else if decode_mcu_result == 1 { + // No-op. + } else if decode_mcu_result == 2 { return "#internal error: inconsistent decoder state" + } else { + return this.swizzle_immediately_status } while.fill_bitstream true, @@ -1586,6 +1653,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool { var b : base.u32 var bx_offset : base.u32 var by_offset : base.u32 + var sibo : base.u32 var ssel : base.u8[..= 3] var csel : base.u8[..= 3] @@ -1600,6 +1668,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool { v = this.components_v[this.scan_comps_cselector[i]] as base.u32 hv = ((this.components_h[this.scan_comps_cselector[i]] as base.u32) * (this.components_v[this.scan_comps_cselector[i]] as base.u32)) + this.swizzle_immediately_c_offsets[i] = 64 ~mod* total_hv total_hv ~mod+= hv while hv > 0, @@ -1626,6 +1695,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool { return true } this.mcu_num_blocks = total_hv + this.swizzle_immediately_c_offsets[this.scan_num_components] = 64 ~mod* total_hv b = 0 while b < this.mcu_num_blocks { @@ -1639,6 +1709,10 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool { this.mcu_blocks_my_mul[b] = 8 * (this.components_v[csel] as base.u32) * this.components_workbuf_widths[csel] this.mcu_blocks_dc_hselector[b] = 0 | this.scan_comps_td[ssel] this.mcu_blocks_ac_hselector[b] = 4 | this.scan_comps_ta[ssel] + sibo = this.swizzle_immediately_c_offsets[csel] ~mod+ ( + (8 * (this.scan_comps_bx_offset[b] as base.u32)) + + (64 * (this.scan_comps_by_offset[b] as base.u32) * (this.components_h[csel] as base.u32))) + this.swizzle_immediately_b_offsets[b] = sibo.min(no_more_than: 576) b += 1 } @@ -1927,15 +2001,16 @@ pri func decoder.apply_progressive_idct!(workbuf: slice base.u8) { this.mcu_blocks[.. 1].bulk_load_host_endian!(src: stashed_mcu_blocks_0[..]) } -pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status { +pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, x0: base.u32, x1: base.u32, y0: base.u32, y1: base.u32, stride: base.u64) base.status { var dst_pixfmt : base.pixel_format var dst_bits_per_pixel : base.u32[..= 256] var dst_bytes_per_pixel : base.u32[..= 32] - var dst_length : base.u64 + var x0 : base.u64 + var x1 : base.u64 var tab : table base.u8 var dst : slice base.u8 var y : base.u32 - var stride : base.u64[..= 0x4_0000] + var y1 : base.u32[..= 0xFFFF] // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()". @@ -1945,79 +2020,143 @@ pri func decoder.swizzle_gray!(dst: ptr base.pixel_buffer, workbuf: slice base.u return base."#unsupported option" } dst_bytes_per_pixel = dst_bits_per_pixel / 8 - dst_length = (dst_bytes_per_pixel * this.width) as base.u64 + x0 = (dst_bytes_per_pixel * args.x0.min(no_more_than: this.width)) as base.u64 + x1 = (dst_bytes_per_pixel * args.x1.min(no_more_than: this.width)) as base.u64 tab = args.dst.plane(p: 0) - y = 0 - while y < this.height { - assert y < 0xFFFF via "a < b: a < c; c <= b"(c: this.height) + y = args.y0 + y1 = args.y1.min(no_more_than: this.height) + while y < y1 { + assert y < 0xFFFF via "a < b: a < c; c <= b"(c: y1) dst = tab.row_u32(y: y) - if dst_length < dst.length() { - dst = dst[.. dst_length] + if x1 < dst.length() { + dst = dst[.. x1] } + if x0 < dst.length() { + dst = dst[x0 ..] + } else { + dst = this.util.empty_slice_u8() + } + this.swizzler.swizzle_interleaved_from_slice!( dst: dst, dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]), src: args.workbuf) - stride = this.components_workbuf_widths[0] as base.u64 - if stride <= args.workbuf.length() { - args.workbuf = args.workbuf[stride ..] + + if args.stride <= args.workbuf.length() { + args.workbuf = args.workbuf[args.stride ..] } else { args.workbuf = this.util.empty_slice_u8() } + y += 1 } return ok } -pri func decoder.swizzle_colorful!(dst: ptr base.pixel_buffer, workbuf: slice base.u8) base.status { - var src0 : slice base.u8 - var src1 : slice base.u8 - var src2 : slice base.u8 - var src3 : slice base.u8 - var status : base.status +pri func decoder.swizzle_colorful!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, x0: base.u32, x1: base.u32, y0: base.u32, y1: base.u32) base.status { + var i : base.u64 + var j : base.u64 + var src0 : slice base.u8 + var src1 : slice base.u8 + var src2 : slice base.u8 + var src3 : slice base.u8 + var width0 : base.u32[..= 0x1_0008] + var width1 : base.u32[..= 0x1_0008] + var width2 : base.u32[..= 0x1_0008] + var width3 : base.u32[..= 0x1_0008] + var height0 : base.u32[..= 0x1_0008] + var height1 : base.u32[..= 0x1_0008] + var height2 : base.u32[..= 0x1_0008] + var height3 : base.u32[..= 0x1_0008] + var status : base.status - if (this.components_workbuf_offsets[0] <= this.components_workbuf_offsets[1]) and - (this.components_workbuf_offsets[1] <= args.workbuf.length()) { - src0 = args.workbuf[this.components_workbuf_offsets[0] .. this.components_workbuf_offsets[1]] - } + if this.swizzle_immediately { + i = this.swizzle_immediately_c_offsets[0] as base.u64 + j = this.swizzle_immediately_c_offsets[1] as base.u64 + if (i <= j) and (j <= 640) { + src0 = this.swizzle_immediately_buffer[i .. j] + width0 = 8 * (this.components_h[0] as base.u32) + height0 = 8 * (this.components_v[0] as base.u32) + } - if (this.components_workbuf_offsets[1] <= this.components_workbuf_offsets[2]) and - (this.components_workbuf_offsets[2] <= args.workbuf.length()) { - src1 = args.workbuf[this.components_workbuf_offsets[1] .. this.components_workbuf_offsets[2]] - } + i = this.swizzle_immediately_c_offsets[1] as base.u64 + j = this.swizzle_immediately_c_offsets[2] as base.u64 + if (i <= j) and (j <= 640) { + src1 = this.swizzle_immediately_buffer[i .. j] + width1 = 8 * (this.components_h[1] as base.u32) + height1 = 8 * (this.components_v[1] as base.u32) + } - if (this.components_workbuf_offsets[2] <= this.components_workbuf_offsets[3]) and - (this.components_workbuf_offsets[3] <= args.workbuf.length()) { - src2 = args.workbuf[this.components_workbuf_offsets[2] .. this.components_workbuf_offsets[3]] - } + i = this.swizzle_immediately_c_offsets[2] as base.u64 + j = this.swizzle_immediately_c_offsets[3] as base.u64 + if (i <= j) and (j <= 640) { + src2 = this.swizzle_immediately_buffer[i .. j] + width2 = 8 * (this.components_h[2] as base.u32) + height2 = 8 * (this.components_v[2] as base.u32) + } - if (this.components_workbuf_offsets[3] <= this.components_workbuf_offsets[4]) and - (this.components_workbuf_offsets[4] <= args.workbuf.length()) { - src3 = args.workbuf[this.components_workbuf_offsets[3] .. this.components_workbuf_offsets[4]] + i = this.swizzle_immediately_c_offsets[3] as base.u64 + j = this.swizzle_immediately_c_offsets[4] as base.u64 + if (i <= j) and (j <= 640) { + src3 = this.swizzle_immediately_buffer[i .. j] + width3 = 8 * (this.components_h[3] as base.u32) + height3 = 8 * (this.components_v[3] as base.u32) + } + + } else { + if (this.components_workbuf_offsets[0] <= this.components_workbuf_offsets[1]) and + (this.components_workbuf_offsets[1] <= args.workbuf.length()) { + src0 = args.workbuf[this.components_workbuf_offsets[0] .. this.components_workbuf_offsets[1]] + width0 = this.components_workbuf_widths[0] + height0 = this.components_workbuf_heights[0] + } + + if (this.components_workbuf_offsets[1] <= this.components_workbuf_offsets[2]) and + (this.components_workbuf_offsets[2] <= args.workbuf.length()) { + src1 = args.workbuf[this.components_workbuf_offsets[1] .. this.components_workbuf_offsets[2]] + width1 = this.components_workbuf_widths[1] + height1 = this.components_workbuf_heights[1] + } + + if (this.components_workbuf_offsets[2] <= this.components_workbuf_offsets[3]) and + (this.components_workbuf_offsets[3] <= args.workbuf.length()) { + src2 = args.workbuf[this.components_workbuf_offsets[2] .. this.components_workbuf_offsets[3]] + width2 = this.components_workbuf_widths[2] + height2 = this.components_workbuf_heights[2] + } + + if (this.components_workbuf_offsets[3] <= this.components_workbuf_offsets[4]) and + (this.components_workbuf_offsets[4] <= args.workbuf.length()) { + src3 = args.workbuf[this.components_workbuf_offsets[3] .. this.components_workbuf_offsets[4]] + width3 = this.components_workbuf_widths[3] + height3 = this.components_workbuf_heights[3] + } } status = this.swizzler.swizzle_ycck!( dst: args.dst, dst_palette: args.dst.palette_or_else(fallback: this.dst_palette[..]), - width: this.width, - height: this.height, + x_min_incl: args.x0 & 0xFFFF, + x_max_excl: args.x1.min(no_more_than: this.width), + y_min_incl: args.y0 & 0xFFFF, + y_max_excl: args.y1.min(no_more_than: this.height), src0: src0, src1: src1, src2: src2, src3: src3, - width0: this.components_workbuf_widths[0], - width1: this.components_workbuf_widths[1], - width2: this.components_workbuf_widths[2], - width3: this.components_workbuf_widths[3], - height0: this.components_workbuf_heights[0], - height1: this.components_workbuf_heights[1], - height2: this.components_workbuf_heights[2], - height3: this.components_workbuf_heights[3], - stride0: this.components_workbuf_widths[0], - stride1: this.components_workbuf_widths[1], - stride2: this.components_workbuf_widths[2], - stride3: this.components_workbuf_widths[3], + width0: width0, + width1: width1, + width2: width2, + width3: width3, + height0: height0, + height1: height1, + height2: height2, + height3: height3, + stride0: width0, + stride1: width1, + stride2: width2, + stride3: width3, h0: this.components_h[0], h1: this.components_h[1], h2: this.components_h[2], @@ -2027,7 +2166,7 @@ pri func decoder.swizzle_colorful!(dst: ptr base.pixel_buffer, workbuf: slice ba v2: this.components_v[2], v3: this.components_v[3], is_rgb_or_cmyk: this.is_rgb_or_cmyk, - triangle_filter_for_2to1: true, + triangle_filter_for_2to1: not (this.use_lower_quality and (this.num_components < 4)), scratch_buffer_2k: this.swizzle_ycck_scratch_buffer_2k[..]) return status } @@ -2119,6 +2258,11 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform } pub func decoder.workbuf_len() base.range_ii_u64 { + if this.use_lower_quality and (this.num_components < 4) and (this.sof_marker < 0xC2) { + return this.util.make_range_ii_u64( + min_incl: 0, + max_incl: this.components_workbuf_offsets[8]) + } return this.util.make_range_ii_u64( min_incl: this.components_workbuf_offsets[8], max_incl: this.components_workbuf_offsets[8]) diff --git a/std/jpeg/decode_mcu_default.wuffs b/std/jpeg/decode_mcu_default.wuffs index 25cffec5..d3044530 100644 --- a/std/jpeg/decode_mcu_default.wuffs +++ b/std/jpeg/decode_mcu_default.wuffs @@ -8,7 +8,7 @@ // // SPDX-License-Identifier: Apache-2.0 OR MIT -pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32, +pri func decoder.decode_mcu!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32, choosy, { var ret : base.u32 @@ -266,17 +266,62 @@ pri func decoder.decode_mcu!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], m } // Apply IDCT. - csel = this.scan_comps_cselector[this.mcu_blocks_sselector[mcb]] - stride = this.components_workbuf_widths[csel] as base.u64 - offset = this.mcu_blocks_offset[mcb] + - ((this.mcu_blocks_mx_mul[mcb] as base.u64) * (args.mx as base.u64)) + - ((this.mcu_blocks_my_mul[mcb] as base.u64) * (args.my as base.u64)) - if offset <= args.workbuf.length() { + + if not this.swizzle_immediately { + csel = this.scan_comps_cselector[this.mcu_blocks_sselector[mcb]] + stride = this.components_workbuf_widths[csel] as base.u64 + offset = this.mcu_blocks_offset[mcb] + + ((this.mcu_blocks_mx_mul[mcb] as base.u64) * (args.mx as base.u64)) + + ((this.mcu_blocks_my_mul[mcb] as base.u64) * (args.my as base.u64)) + if offset <= args.workbuf.length() { + this.decode_idct!( + dst_buffer: args.workbuf[offset ..], + dst_stride: stride, + q: this.components_tq[csel] as base.u32) + + } + + } else if this.num_components == 1 { this.decode_idct!( - dst_buffer: args.workbuf[offset ..], + dst_buffer: this.swizzle_immediately_buffer[.. 64], + dst_stride: 8, + q: this.components_tq[csel] as base.u32) + this.swizzle_immediately_status = this.swizzle_gray!( + dst: args.dst, + workbuf: this.swizzle_immediately_buffer[.. 64], + x0: (args.mx + 0) * 8, + x1: (args.mx + 1) * 8, + y0: (args.my + 0) * 8, + y1: (args.my + 1) * 8, + stride: 8) + if not this.swizzle_immediately_status.is_ok() { + ret = 3 // Swizzling failure. + break.goto_done + } + break.block + + } else { + csel = this.scan_comps_cselector[this.mcu_blocks_sselector[mcb]] + stride = 8 * (this.components_h[csel] as base.u64) + this.decode_idct!( + dst_buffer: this.swizzle_immediately_buffer[this.swizzle_immediately_b_offsets[mcb] ..], dst_stride: stride, q: this.components_tq[csel] as base.u32) - + if this.mcu_current_block < this.mcu_num_blocks { + continue.block + } + this.swizzle_immediately_status = this.swizzle_colorful!( + dst: args.dst, + workbuf: this.util.empty_slice_u8(), + x0: (args.mx + 0) * 8 * (this.max_incl_components_h as base.u32), + x1: (args.mx + 1) * 8 * (this.max_incl_components_h as base.u32), + y0: (args.my + 0) * 8 * (this.max_incl_components_v as base.u32), + y1: (args.my + 1) * 8 * (this.max_incl_components_v as base.u32)) + if not this.swizzle_immediately_status.is_ok() { + ret = 3 // Swizzling failure. + break.goto_done + } + break.block } }.block this.mcu_current_block = 0 diff --git a/std/jpeg/decode_mcu_progressive_ac_high_bits.wuffs b/std/jpeg/decode_mcu_progressive_ac_high_bits.wuffs index c7fe13a8..3f2de996 100644 --- a/std/jpeg/decode_mcu_progressive_ac_high_bits.wuffs +++ b/std/jpeg/decode_mcu_progressive_ac_high_bits.wuffs @@ -8,7 +8,7 @@ // // SPDX-License-Identifier: Apache-2.0 OR MIT -pri func decoder.decode_mcu_progressive_ac_high_bits!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { +pri func decoder.decode_mcu_progressive_ac_high_bits!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { var ret : base.u32 var bits : base.u64 diff --git a/std/jpeg/decode_mcu_progressive_ac_low_bit.wuffs b/std/jpeg/decode_mcu_progressive_ac_low_bit.wuffs index 5dd97ca7..7a8f4868 100644 --- a/std/jpeg/decode_mcu_progressive_ac_low_bit.wuffs +++ b/std/jpeg/decode_mcu_progressive_ac_low_bit.wuffs @@ -8,7 +8,7 @@ // // SPDX-License-Identifier: Apache-2.0 OR MIT -pri func decoder.decode_mcu_progressive_ac_low_bit!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { +pri func decoder.decode_mcu_progressive_ac_low_bit!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { var ret : base.u32 var bits : base.u64 diff --git a/std/jpeg/decode_mcu_progressive_dc_high_bits.wuffs b/std/jpeg/decode_mcu_progressive_dc_high_bits.wuffs index f01f920b..6ac6b924 100644 --- a/std/jpeg/decode_mcu_progressive_dc_high_bits.wuffs +++ b/std/jpeg/decode_mcu_progressive_dc_high_bits.wuffs @@ -8,7 +8,7 @@ // // SPDX-License-Identifier: Apache-2.0 OR MIT -pri func decoder.decode_mcu_progressive_dc_high_bits!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { +pri func decoder.decode_mcu_progressive_dc_high_bits!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { var ret : base.u32 var bits : base.u64 diff --git a/std/jpeg/decode_mcu_progressive_dc_low_bit.wuffs b/std/jpeg/decode_mcu_progressive_dc_low_bit.wuffs index 21f2d708..0dadead5 100644 --- a/std/jpeg/decode_mcu_progressive_dc_low_bit.wuffs +++ b/std/jpeg/decode_mcu_progressive_dc_low_bit.wuffs @@ -8,7 +8,7 @@ // // SPDX-License-Identifier: Apache-2.0 OR MIT -pri func decoder.decode_mcu_progressive_dc_low_bit!(workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { +pri func decoder.decode_mcu_progressive_dc_low_bit!(dst: ptr base.pixel_buffer, workbuf: slice base.u8, mx: base.u32[..= 0x1FFF], my: base.u32[..= 0x1FFF]) base.u32 { var ret : base.u32 var bits : base.u64 diff --git a/test/c/std/jpeg.c b/test/c/std/jpeg.c index 3ccccb66..992cf8a3 100644 --- a/test/c/std/jpeg.c +++ b/test/c/std/jpeg.c @@ -95,6 +95,48 @@ test_wuffs_jpeg_decode_interface() { "test/data/bricks-color.jpeg", 0, SIZE_MAX, 160, 120, 0xFF012466); } +const char* // +test_wuffs_jpeg_decode_lower_quality() { + CHECK_FOCUS(__func__); + wuffs_jpeg__decoder dec; + CHECK_STATUS("initialize", + wuffs_jpeg__decoder__initialize( + &dec, sizeof dec, WUFFS_VERSION, + WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); + wuffs_jpeg__decoder__set_quirk( + &dec, WUFFS_BASE__QUIRK_QUALITY, + WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY); + CHECK_STRING(do_test__wuffs_base__image_decoder( + wuffs_jpeg__decoder__upcast_as__wuffs_base__image_decoder(&dec), + "test/data/bricks-color.jpeg", 0, SIZE_MAX, 160, 120, 0xFF012466)); + + wuffs_base__io_buffer src = ((wuffs_base__io_buffer){ + .data = g_src_slice_u8, + }); + CHECK_STRING(read_file(&src, "test/data/bricks-color.jpeg")); + CHECK_STATUS("initialize", wuffs_jpeg__decoder__initialize( + &dec, sizeof dec, WUFFS_VERSION, + WUFFS_INITIALIZE__DEFAULT_OPTIONS)); + CHECK_STATUS("decode_image_config", + wuffs_jpeg__decoder__decode_image_config(&dec, NULL, &src)); + + for (int q = 0; q < 2; q++) { + if (q) { + wuffs_jpeg__decoder__set_quirk( + &dec, WUFFS_BASE__QUIRK_QUALITY, + WUFFS_BASE__QUIRK_QUALITY__VALUE__LOWER_QUALITY); + } + uint64_t m = wuffs_jpeg__decoder__workbuf_len(&dec).min_incl; + if ((q == 0) && (m == 0)) { + RETURN_FAIL("q=%d: have %" PRIu64 ", want non-zero", q, m); + } else if ((q != 0) && (m != 0)) { + RETURN_FAIL("q=%d: have %" PRIu64 ", want zero", q, m); + } + } + + return NULL; +} + const char* // test_wuffs_jpeg_decode_truncated_input() { CHECK_FOCUS(__func__); @@ -739,8 +781,9 @@ test_wuffs_jpeg_decode_mcu() { for (int b = 0; b < 6; b++) { const uint32_t mx = 0; const uint32_t my = 0; - if (wuffs_jpeg__decoder__decode_mcu(&dec, wuffs_base__empty_slice_u8(), mx, - my)) { + wuffs_base__pixel_buffer dst = {0}; + if (wuffs_jpeg__decoder__decode_mcu(&dec, &dst, + wuffs_base__empty_slice_u8(), mx, my)) { RETURN_FAIL("decode_mcu failed"); } @@ -988,6 +1031,7 @@ proc g_tests[] = { test_wuffs_jpeg_decode_idct, test_wuffs_jpeg_decode_mcu, test_wuffs_jpeg_decode_interface, + test_wuffs_jpeg_decode_lower_quality, test_wuffs_jpeg_decode_truncated_input, #ifdef WUFFS_MIMIC