std/jpeg: add and use WUFFS_BASE__QUIRK_QUALITY

This commit is contained in:
Nigel Tao committed 2024-08-04 23:15:58 +10:00
1 parent fb769ff82f
commit c9fff5b207
17 files changed
+986 -335

No files matched your search

+1
View File
@@ -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`.
+10
View File
@@ -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:
+11 -1
View File
@@ -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.
+34 -12
View File
@@ -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, //
+7
View File
@@ -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);
}
+14
View File
@@ -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)
+4 -2
View File
@@ -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,
+162 -91
View File
@@ -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);
}
+5 -2
View File
@@ -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," +
+433 -155
View File
@@ -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);
}
+201 -57
View File
@@ -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])
+54 -9
View File
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
+46 -2
View File
@@ -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