std/jpeg: prepare for triangle-filter upsampling
diff --git a/fuzz/c/std/pixel_swizzler_fuzzer.c b/fuzz/c/std/pixel_swizzler_fuzzer.c
index aafe60a..a73a462 100644
--- a/fuzz/c/std/pixel_swizzler_fuzzer.c
+++ b/fuzz/c/std/pixel_swizzler_fuzzer.c
@@ -234,7 +234,7 @@
uint32_t v0 = possible_hv_values[allow_hv3][3 & (hash >> 31)];
uint32_t v1 = possible_hv_values[allow_hv3][3 & (hash >> 33)];
uint32_t v2 = possible_hv_values[allow_hv3][3 & (hash >> 35)];
- // TODO: spend a hash bit for triangle_filter_for_2to1.
+ bool triangle_filter_for_2to1 = 1 & (hash >> 37);
uint32_t width0 = 8 * width_in_mcus * h0;
uint32_t width1 = 8 * width_in_mcus * h1;
@@ -339,6 +339,7 @@
wuffs_base__slice_u8 src3 = wuffs_base__empty_slice_u8();
wuffs_base__pixel_swizzler swizzler = {0};
+ uint8_t scratch_buffer[2048];
wuffs_base__status status = wuffs_base__pixel_swizzler__swizzle_ycck(
&swizzler, &dst_pixbuf, dst_palette, //
width, height, //
@@ -348,7 +349,8 @@
width0, width1, width2, 0, //
h0, h1, h2, 0, //
v0, v1, v2, 0, //
- false);
+ triangle_filter_for_2to1, //
+ wuffs_base__make_slice_u8(scratch_buffer, sizeof(scratch_buffer)));
if (status.repr) {
return wuffs_base__status__message(&status);
}
diff --git a/internal/cgen/base/image-private.h b/internal/cgen/base/image-private.h
index 7d3f01d..83807ae 100644
--- a/internal/cgen/base/image-private.h
+++ b/internal/cgen/base/image-private.h
@@ -39,36 +39,38 @@
uint64_t num_pixels);
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
-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,
- wuffs_base__slice_u8 src0,
- wuffs_base__slice_u8 src1,
- wuffs_base__slice_u8 src2,
- wuffs_base__slice_u8 src3,
- uint32_t width0,
- uint32_t width1,
- uint32_t width2,
- uint32_t width3,
- uint32_t height0,
- uint32_t height1,
- uint32_t height2,
- uint32_t height3,
- uint32_t stride0,
- uint32_t stride1,
- uint32_t stride2,
- uint32_t stride3,
- uint8_t h0,
- uint8_t h1,
- uint8_t h2,
- uint8_t h3,
- uint8_t v0,
- uint8_t v1,
- uint8_t v2,
- uint8_t v3,
- bool triangle_filter_for_2to1);
+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,
+ wuffs_base__slice_u8 src0,
+ wuffs_base__slice_u8 src1,
+ wuffs_base__slice_u8 src2,
+ wuffs_base__slice_u8 src3,
+ uint32_t width0,
+ uint32_t width1,
+ uint32_t width2,
+ uint32_t width3,
+ uint32_t height0,
+ uint32_t height1,
+ uint32_t height2,
+ uint32_t height3,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t stride3,
+ uint8_t h0,
+ uint8_t h1,
+ uint8_t h2,
+ uint8_t h3,
+ uint8_t v0,
+ uint8_t v1,
+ uint8_t v2,
+ uint8_t v3,
+ bool triangle_filter_for_2to1,
+ wuffs_base__slice_u8 scratch_buffer_2k);
// ---------------- Images (Utility)
diff --git a/internal/cgen/base/pixconv-submodule-ycck.c b/internal/cgen/base/pixconv-submodule-ycck.c
index 6705692..004b1e2 100644
--- a/internal/cgen/base/pixconv-submodule-ycck.c
+++ b/internal/cgen/base/pixconv-submodule-ycck.c
@@ -34,14 +34,241 @@
e);
}
-// Preconditions: see all the checks made in
-// wuffs_base__pixel_swizzler__swizzle_ycck before calling this function. For
+// --------
+
+// wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upsamples to a
+// destination slice at least 480 (YCCK) or 672 (YCC) bytes long and whose
+// src_len (multiplied by 1, 2, 3 or 4) is positive but no more than that. This
+// 480 or 672 length is just under 1/4 or 1/3 of the scratch_buffer_2k slice
+// length. Both (480 * 4) = 1920 and (672 * 3) = 2016 are less than 2048.
+//
+// 480 and 672 are nice round numbers because a JPEG MCU is 1, 2, 3 or 4 blocks
+// wide and each block is 8 pixels wide. We have:
+// 480 = 1 * 8 * 60, 672 = 1 * 8 * 84
+// 480 = 2 * 8 * 30, 672 = 2 * 8 * 42
+// 480 = 3 * 8 * 20, 672 = 3 * 8 * 28
+// 480 = 4 * 8 * 15, 672 = 4 * 8 * 21
+//
+// Box filters are equivalent to nearest neighbor upsampling. These ignore the
+// src_ptr_minor, h1v2_bias, first_column and last_column arguments.
+//
+// TODO: triangle filters.
+typedef const uint8_t* (
+ *wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func)(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major, // Nearest row.
+ const uint8_t* src_ptr_minor, // Adjacent row, alternating above or below.
+ size_t src_len,
+ uint32_t h1v2_bias,
+ bool first_column,
+ bool last_column);
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ return src_ptr_major;
+}
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ uint8_t* dp = dst_ptr;
+ const uint8_t* sp = src_ptr_major;
+ while (src_len--) {
+ uint8_t sv = *sp++;
+ *dp++ = sv;
+ *dp++ = sv;
+ }
+ return dst_ptr;
+}
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ uint8_t* dp = dst_ptr;
+ const uint8_t* sp = src_ptr_major;
+ while (src_len--) {
+ uint8_t sv = *sp++;
+ *dp++ = sv;
+ *dp++ = sv;
+ *dp++ = sv;
+ }
+ return dst_ptr;
+}
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ uint8_t* dp = dst_ptr;
+ const uint8_t* sp = src_ptr_major;
+ while (src_len--) {
+ uint8_t sv = *sp++;
+ *dp++ = sv;
+ *dp++ = sv;
+ *dp++ = sv;
+ *dp++ = sv;
+ }
+ return dst_ptr;
+}
+
+// wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs is indexed by inv_h
+// and then inv_v.
+static const wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs[4][4] = {
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ },
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ },
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ },
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ },
+};
+
+static inline uint32_t //
+wuffs_base__pixel_swizzler__has_triangle_upsampler(uint32_t inv_h,
+ uint32_t inv_v) {
+ if (inv_h == 1u) {
+ return inv_v == 2u;
+ } else if (inv_h == 2u) {
+ return (inv_v == 1u) || (inv_v == 2u);
+ }
+ return false;
+}
+
+// --------
+
+// All of the wuffs_base__pixel_swizzler__swizzle_ycc__etc functions have
+// preconditions. See all of the checks made in
+// wuffs_base__pixel_swizzler__swizzle_ycck before calling these functions. For
// example, (width > 0) is a precondition, but there are many more.
+
static void //
-wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
- const wuffs_base__pixel_swizzler* p,
+wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter_single_row(
wuffs_base__pixel_buffer* dst,
- wuffs_base__slice_u8 dst_palette,
+ uint32_t width,
+ uint32_t y,
+ const uint8_t* src_ptr0,
+ const uint8_t* src_ptr1,
+ const uint8_t* src_ptr2,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t inv_h0,
+ uint32_t inv_h1,
+ uint32_t inv_h2,
+ uint32_t inv_v0,
+ uint32_t inv_v1,
+ uint32_t inv_v2,
+ uint32_t half_width_for_2to1,
+ uint32_t h1v2_bias,
+ uint8_t* scratch_buffer_2k_ptr,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2) {
+ const uint8_t* src0 = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
+ const uint8_t* src1 = src_ptr1 + ((y / inv_v1) * (size_t)stride1);
+ const uint8_t* src2 = src_ptr2 + ((y / inv_v2) * (size_t)stride2);
+ uint32_t total_src_len0 = 0u;
+ uint32_t total_src_len1 = 0u;
+ uint32_t total_src_len2 = 0u;
+
+ uint32_t x = 0u;
+ while (x < width) {
+ bool first_column = x == 0u;
+ uint32_t end = x + 672u;
+ if (end > width) {
+ end = width;
+ }
+
+ 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;
+ total_src_len0 += src_len0;
+ total_src_len1 += src_len1;
+ total_src_len2 += src_len2;
+
+ const uint8_t* src_ptr_x0 = src0 + (x / inv_h0);
+ const uint8_t* up0 = (*upfunc0)( //
+ scratch_buffer_2k_ptr + (0u * 672u), //
+ src_ptr_x0, //
+ src_ptr_x0, //
+ src_len0, //
+ h1v2_bias, //
+ first_column, //
+ (total_src_len0 >= half_width_for_2to1));
+
+ const uint8_t* src_ptr_x1 = src1 + (x / inv_h1);
+ const uint8_t* up1 = (*upfunc1)( //
+ scratch_buffer_2k_ptr + (1u * 672u), //
+ src_ptr_x1, //
+ src_ptr_x1, //
+ src_len1, //
+ h1v2_bias, //
+ first_column, //
+ (total_src_len1 >= half_width_for_2to1));
+
+ const uint8_t* src_ptr_x2 = src2 + (x / inv_h2);
+ const uint8_t* up2 = (*upfunc2)( //
+ scratch_buffer_2k_ptr + (2u * 672u), //
+ src_ptr_x2, //
+ src_ptr_x2, //
+ src_len2, //
+ h1v2_bias, //
+ first_column, //
+ (total_src_len2 >= half_width_for_2to1));
+
+ for (; x < end; x++) {
+ wuffs_base__pixel_buffer__set_color_u32_at(
+ dst, x, y,
+ wuffs_base__color_ycc__as__color_u32(*up0++, *up1++, *up2++));
+ }
+ }
+}
+
+static void //
+wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter(
+ wuffs_base__pixel_buffer* dst,
uint32_t width,
uint32_t height,
const uint8_t* src_ptr0,
@@ -50,74 +277,129 @@
uint32_t stride0,
uint32_t stride1,
uint32_t stride2,
- uint32_t h0_out_of_12,
- uint32_t h1_out_of_12,
- uint32_t h2_out_of_12,
- uint32_t v0_out_of_12,
- uint32_t v1_out_of_12,
- uint32_t v2_out_of_12) {
- uint32_t iy0 = 0;
- uint32_t iy1 = 0;
- uint32_t iy2 = 0;
- uint32_t y = 0;
+ uint32_t inv_h0,
+ uint32_t inv_h1,
+ uint32_t inv_h2,
+ uint32_t inv_v0,
+ uint32_t inv_v1,
+ uint32_t inv_v2,
+ uint32_t half_width_for_2to1,
+ uint32_t half_height_for_2to1,
+ uint8_t* scratch_buffer_2k_ptr) {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0 =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs
+ [(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1 =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs
+ [(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2 =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs
+ [(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
+
+ uint32_t y;
+ for (y = 0u; y < height; y++) {
+ wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter_single_row(
+ dst, width, y, //
+ 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, //
+ 0u, //
+ scratch_buffer_2k_ptr, //
+ upfunc0, upfunc1, upfunc2);
+ }
+}
+
+static void //
+wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
+ wuffs_base__pixel_buffer* dst,
+ uint32_t width,
+ uint32_t height,
+ const uint8_t* src_ptr0,
+ const uint8_t* src_ptr1,
+ const uint8_t* src_ptr2,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t inv_h0,
+ uint32_t inv_h1,
+ uint32_t inv_h2,
+ uint32_t inv_v0,
+ uint32_t inv_v1,
+ uint32_t inv_v2) {
+ // Convert an inv_h or inv_v value from {1, 2, 3, 4} to {12, 6, 4, 3}.
+ uint32_t h0_out_of_12 = 12u / inv_h0;
+ uint32_t h1_out_of_12 = 12u / inv_h1;
+ uint32_t h2_out_of_12 = 12u / inv_h2;
+ uint32_t v0_out_of_12 = 12u / inv_v0;
+ uint32_t v1_out_of_12 = 12u / inv_v1;
+ uint32_t v2_out_of_12 = 12u / inv_v2;
+
+ uint32_t iy0 = 0u;
+ uint32_t iy1 = 0u;
+ uint32_t iy2 = 0u;
+ uint32_t y = 0u;
while (true) {
const uint8_t* src_iter0 = src_ptr0;
const uint8_t* src_iter1 = src_ptr1;
const uint8_t* src_iter2 = src_ptr2;
- uint32_t ix0 = 0;
- uint32_t ix1 = 0;
- uint32_t ix2 = 0;
- uint32_t x = 0;
+ uint32_t ix0 = 0u;
+ uint32_t ix1 = 0u;
+ uint32_t ix2 = 0u;
+ uint32_t x = 0u;
while (true) {
wuffs_base__pixel_buffer__set_color_u32_at(
dst, x, y,
wuffs_base__color_ycc__as__color_u32(*src_iter0, *src_iter1,
*src_iter2));
- if ((x + 1) == width) {
+ if ((x + 1u) == width) {
break;
}
- x = x + 1;
+ x = x + 1u;
ix0 += h0_out_of_12;
- if (ix0 >= 12) {
- ix0 = 0;
+ if (ix0 >= 12u) {
+ ix0 = 0u;
src_iter0++;
}
ix1 += h1_out_of_12;
- if (ix1 >= 12) {
- ix1 = 0;
+ if (ix1 >= 12u) {
+ ix1 = 0u;
src_iter1++;
}
ix2 += h2_out_of_12;
- if (ix2 >= 12) {
- ix2 = 0;
+ if (ix2 >= 12u) {
+ ix2 = 0u;
src_iter2++;
}
}
- if ((y + 1) == height) {
+ if ((y + 1u) == height) {
break;
}
- y = y + 1;
+ y = y + 1u;
iy0 += v0_out_of_12;
- if (iy0 >= 12) {
- iy0 = 0;
+ if (iy0 >= 12u) {
+ iy0 = 0u;
src_ptr0 += stride0;
}
iy1 += v1_out_of_12;
- if (iy1 >= 12) {
- iy1 = 0;
+ if (iy1 >= 12u) {
+ iy1 = 0u;
src_ptr1 += stride1;
}
iy2 += v2_out_of_12;
- if (iy2 >= 12) {
- iy2 = 0;
+ if (iy2 >= 12u) {
+ iy2 = 0u;
src_ptr2 += stride2;
}
}
}
+// --------
+
// wuffs_base__pixel_swizzler__flattened_length is like
// wuffs_base__table__flattened_length but returns uint64_t (not size_t) and
// also accounts for subsampling.
@@ -127,66 +409,78 @@
uint32_t stride,
uint32_t inv_h,
uint32_t inv_v) {
- uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1)) / inv_h;
- uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1)) / inv_v;
- if (scaled_height <= 0) {
- return 0;
+ uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1u)) / inv_h;
+ uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1u)) / inv_v;
+ if (scaled_height <= 0u) {
+ return 0u;
}
- return ((scaled_height - 1) * stride) + scaled_width;
+ return ((scaled_height - 1u) * stride) + scaled_width;
}
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
-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,
- wuffs_base__slice_u8 src0,
- wuffs_base__slice_u8 src1,
- wuffs_base__slice_u8 src2,
- wuffs_base__slice_u8 src3,
- uint32_t width0,
- uint32_t width1,
- uint32_t width2,
- uint32_t width3,
- uint32_t height0,
- uint32_t height1,
- uint32_t height2,
- uint32_t height3,
- uint32_t stride0,
- uint32_t stride1,
- uint32_t stride2,
- uint32_t stride3,
- uint8_t h0,
- uint8_t h1,
- uint8_t h2,
- uint8_t h3,
- uint8_t v0,
- uint8_t v1,
- uint8_t v2,
- uint8_t v3,
- bool triangle_filter_for_2to1) {
+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,
+ wuffs_base__slice_u8 src0,
+ wuffs_base__slice_u8 src1,
+ wuffs_base__slice_u8 src2,
+ wuffs_base__slice_u8 src3,
+ uint32_t width0,
+ uint32_t width1,
+ uint32_t width2,
+ uint32_t width3,
+ uint32_t height0,
+ uint32_t height1,
+ uint32_t height2,
+ uint32_t height3,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t stride3,
+ uint8_t h0,
+ uint8_t h1,
+ uint8_t h2,
+ uint8_t h3,
+ uint8_t v0,
+ uint8_t v1,
+ uint8_t v2,
+ uint8_t v3,
+ bool triangle_filter_for_2to1,
+ wuffs_base__slice_u8 scratch_buffer_2k) {
if (!p) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
- } else if ((h3 != 0) || (v3 != 0) || triangle_filter_for_2to1) {
- // TODO: support the K in YCCK and support triangle_filter_for_2to1.
+ } else if ((h3 != 0u) || (v3 != 0u)) {
+ // TODO: support the K in YCCK.
return wuffs_base__make_status(
wuffs_base__error__unsupported_pixel_swizzler_option);
- } else if (!dst || (width > 0xFFFF) || (height > 0xFFFF) || //
- (4 <= (h0 - 1)) || (4 <= (v0 - 1)) || //
- (4 <= (h1 - 1)) || (4 <= (v1 - 1)) || //
- (4 <= (h2 - 1)) || (4 <= (v2 - 1))) {
+ } else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || //
+ (4u <= (h0 - 1u)) || (4u <= (v0 - 1u)) || //
+ (4u <= (h1 - 1u)) || (4u <= (v1 - 1u)) || //
+ (4u <= (h2 - 1u)) || (4u <= (v2 - 1u)) || //
+ (scratch_buffer_2k.len < 2048u)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
uint32_t max_incl_h = wuffs_base__u32__max_of_4(h0, h1, h2, h3);
uint32_t max_incl_v = wuffs_base__u32__max_of_4(v0, v1, v2, v3);
+
+ // Calculate the inverse h and v ratios.
+ //
+ // It also canonicalizes (h=2 and max_incl_h=4) as equivalent to (h=1 and
+ // max_incl_h=2). In both cases, the inv_h value is 2.
uint32_t inv_h0 = max_incl_h / h0;
uint32_t inv_h1 = max_incl_h / h1;
uint32_t inv_h2 = max_incl_h / h2;
uint32_t inv_v0 = max_incl_v / v0;
uint32_t inv_v1 = max_incl_v / v1;
uint32_t inv_v2 = max_incl_v / v2;
+
+ uint32_t half_width_for_2to1 = (width + 1u) / 2u;
+ uint32_t half_height_for_2to1 = (height + 1u) / 2u;
+
width = wuffs_base__u32__min_of_5( //
width, //
width0 * inv_h0, //
@@ -246,19 +540,31 @@
wuffs_base__error__unsupported_pixel_swizzler_option);
}
- if ((width <= 0) || (height <= 0)) {
+ if ((width <= 0u) || (height <= 0u)) {
return wuffs_base__make_status(NULL);
}
- wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
- p, dst, dst_palette, width, height, //
- src0.ptr, src1.ptr, src2.ptr, //
- stride0, stride1, stride2, //
- (h0 * 12) / max_incl_h, //
- (h1 * 12) / max_incl_h, //
- (h2 * 12) / max_incl_h, //
- (v0 * 12) / max_incl_v, //
- (v1 * 12) / max_incl_v, //
- (v2 * 12) / max_incl_v);
+ if (triangle_filter_for_2to1 &&
+ (wuffs_base__pixel_swizzler__has_triangle_upsampler(inv_h0, inv_v0) ||
+ wuffs_base__pixel_swizzler__has_triangle_upsampler(inv_h1, inv_v1) ||
+ wuffs_base__pixel_swizzler__has_triangle_upsampler(inv_h2, inv_v2))) {
+ wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter(
+ 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, //
+ scratch_buffer_2k.ptr);
+
+ } else {
+ wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
+ dst, width, height, //
+ src0.ptr, src1.ptr, src2.ptr, //
+ stride0, stride1, stride2, //
+ inv_h0, inv_h1, inv_h2, //
+ inv_v0, inv_v1, inv_v2);
+ }
+
return wuffs_base__make_status(NULL);
}
diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go
index d0c3215..fceef8a 100644
--- a/lang/builtin/builtin.go
+++ b/lang/builtin/builtin.go
@@ -672,7 +672,8 @@
"v1: u8[..= 4]," +
"v2: u8[..= 4]," +
"v3: u8[..= 4]," +
- "triangle_filter_for_2to1: bool) status",
+ "triangle_filter_for_2to1: bool," +
+ "scratch_buffer_2k: slice u8) status",
// ---- arm_crc32_utility
diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c
index e667f57..af37bd6 100644
--- a/release/c/wuffs-unsupported-snapshot.c
+++ b/release/c/wuffs-unsupported-snapshot.c
@@ -12733,36 +12733,38 @@
uint64_t num_pixels);
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
-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,
- wuffs_base__slice_u8 src0,
- wuffs_base__slice_u8 src1,
- wuffs_base__slice_u8 src2,
- wuffs_base__slice_u8 src3,
- uint32_t width0,
- uint32_t width1,
- uint32_t width2,
- uint32_t width3,
- uint32_t height0,
- uint32_t height1,
- uint32_t height2,
- uint32_t height3,
- uint32_t stride0,
- uint32_t stride1,
- uint32_t stride2,
- uint32_t stride3,
- uint8_t h0,
- uint8_t h1,
- uint8_t h2,
- uint8_t h3,
- uint8_t v0,
- uint8_t v1,
- uint8_t v2,
- uint8_t v3,
- bool triangle_filter_for_2to1);
+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,
+ wuffs_base__slice_u8 src0,
+ wuffs_base__slice_u8 src1,
+ wuffs_base__slice_u8 src2,
+ wuffs_base__slice_u8 src3,
+ uint32_t width0,
+ uint32_t width1,
+ uint32_t width2,
+ uint32_t width3,
+ uint32_t height0,
+ uint32_t height1,
+ uint32_t height2,
+ uint32_t height3,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t stride3,
+ uint8_t h0,
+ uint8_t h1,
+ uint8_t h2,
+ uint8_t h3,
+ uint8_t v0,
+ uint8_t v1,
+ uint8_t v2,
+ uint8_t v3,
+ bool triangle_filter_for_2to1,
+ wuffs_base__slice_u8 scratch_buffer_2k);
// ---------------- Images (Utility)
@@ -22680,14 +22682,241 @@
e);
}
-// Preconditions: see all the checks made in
-// wuffs_base__pixel_swizzler__swizzle_ycck before calling this function. For
+// --------
+
+// wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upsamples to a
+// destination slice at least 480 (YCCK) or 672 (YCC) bytes long and whose
+// src_len (multiplied by 1, 2, 3 or 4) is positive but no more than that. This
+// 480 or 672 length is just under 1/4 or 1/3 of the scratch_buffer_2k slice
+// length. Both (480 * 4) = 1920 and (672 * 3) = 2016 are less than 2048.
+//
+// 480 and 672 are nice round numbers because a JPEG MCU is 1, 2, 3 or 4 blocks
+// wide and each block is 8 pixels wide. We have:
+// 480 = 1 * 8 * 60, 672 = 1 * 8 * 84
+// 480 = 2 * 8 * 30, 672 = 2 * 8 * 42
+// 480 = 3 * 8 * 20, 672 = 3 * 8 * 28
+// 480 = 4 * 8 * 15, 672 = 4 * 8 * 21
+//
+// Box filters are equivalent to nearest neighbor upsampling. These ignore the
+// src_ptr_minor, h1v2_bias, first_column and last_column arguments.
+//
+// TODO: triangle filters.
+typedef const uint8_t* (
+ *wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func)(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major, // Nearest row.
+ const uint8_t* src_ptr_minor, // Adjacent row, alternating above or below.
+ size_t src_len,
+ uint32_t h1v2_bias,
+ bool first_column,
+ bool last_column);
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ return src_ptr_major;
+}
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ uint8_t* dp = dst_ptr;
+ const uint8_t* sp = src_ptr_major;
+ while (src_len--) {
+ uint8_t sv = *sp++;
+ *dp++ = sv;
+ *dp++ = sv;
+ }
+ return dst_ptr;
+}
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ uint8_t* dp = dst_ptr;
+ const uint8_t* sp = src_ptr_major;
+ while (src_len--) {
+ uint8_t sv = *sp++;
+ *dp++ = sv;
+ *dp++ = sv;
+ *dp++ = sv;
+ }
+ return dst_ptr;
+}
+
+static const uint8_t* //
+wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box(
+ uint8_t* dst_ptr,
+ const uint8_t* src_ptr_major,
+ const uint8_t* src_ptr_minor_ignored,
+ size_t src_len,
+ uint32_t h1v2_bias_ignored,
+ bool first_column_ignored,
+ bool last_column_ignored) {
+ uint8_t* dp = dst_ptr;
+ const uint8_t* sp = src_ptr_major;
+ while (src_len--) {
+ uint8_t sv = *sp++;
+ *dp++ = sv;
+ *dp++ = sv;
+ *dp++ = sv;
+ *dp++ = sv;
+ }
+ return dst_ptr;
+}
+
+// wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs is indexed by inv_h
+// and then inv_v.
+static const wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs[4][4] = {
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1vn_box,
+ },
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box,
+ },
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h3vn_box,
+ },
+ {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h4vn_box,
+ },
+};
+
+static inline uint32_t //
+wuffs_base__pixel_swizzler__has_triangle_upsampler(uint32_t inv_h,
+ uint32_t inv_v) {
+ if (inv_h == 1u) {
+ return inv_v == 2u;
+ } else if (inv_h == 2u) {
+ return (inv_v == 1u) || (inv_v == 2u);
+ }
+ return false;
+}
+
+// --------
+
+// All of the wuffs_base__pixel_swizzler__swizzle_ycc__etc functions have
+// preconditions. See all of the checks made in
+// wuffs_base__pixel_swizzler__swizzle_ycck before calling these functions. For
// example, (width > 0) is a precondition, but there are many more.
+
static void //
-wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
- const wuffs_base__pixel_swizzler* p,
+wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter_single_row(
wuffs_base__pixel_buffer* dst,
- wuffs_base__slice_u8 dst_palette,
+ uint32_t width,
+ uint32_t y,
+ const uint8_t* src_ptr0,
+ const uint8_t* src_ptr1,
+ const uint8_t* src_ptr2,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t inv_h0,
+ uint32_t inv_h1,
+ uint32_t inv_h2,
+ uint32_t inv_v0,
+ uint32_t inv_v1,
+ uint32_t inv_v2,
+ uint32_t half_width_for_2to1,
+ uint32_t h1v2_bias,
+ uint8_t* scratch_buffer_2k_ptr,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1,
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2) {
+ const uint8_t* src0 = src_ptr0 + ((y / inv_v0) * (size_t)stride0);
+ const uint8_t* src1 = src_ptr1 + ((y / inv_v1) * (size_t)stride1);
+ const uint8_t* src2 = src_ptr2 + ((y / inv_v2) * (size_t)stride2);
+ uint32_t total_src_len0 = 0u;
+ uint32_t total_src_len1 = 0u;
+ uint32_t total_src_len2 = 0u;
+
+ uint32_t x = 0u;
+ while (x < width) {
+ bool first_column = x == 0u;
+ uint32_t end = x + 672u;
+ if (end > width) {
+ end = width;
+ }
+
+ 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;
+ total_src_len0 += src_len0;
+ total_src_len1 += src_len1;
+ total_src_len2 += src_len2;
+
+ const uint8_t* src_ptr_x0 = src0 + (x / inv_h0);
+ const uint8_t* up0 = (*upfunc0)( //
+ scratch_buffer_2k_ptr + (0u * 672u), //
+ src_ptr_x0, //
+ src_ptr_x0, //
+ src_len0, //
+ h1v2_bias, //
+ first_column, //
+ (total_src_len0 >= half_width_for_2to1));
+
+ const uint8_t* src_ptr_x1 = src1 + (x / inv_h1);
+ const uint8_t* up1 = (*upfunc1)( //
+ scratch_buffer_2k_ptr + (1u * 672u), //
+ src_ptr_x1, //
+ src_ptr_x1, //
+ src_len1, //
+ h1v2_bias, //
+ first_column, //
+ (total_src_len1 >= half_width_for_2to1));
+
+ const uint8_t* src_ptr_x2 = src2 + (x / inv_h2);
+ const uint8_t* up2 = (*upfunc2)( //
+ scratch_buffer_2k_ptr + (2u * 672u), //
+ src_ptr_x2, //
+ src_ptr_x2, //
+ src_len2, //
+ h1v2_bias, //
+ first_column, //
+ (total_src_len2 >= half_width_for_2to1));
+
+ for (; x < end; x++) {
+ wuffs_base__pixel_buffer__set_color_u32_at(
+ dst, x, y,
+ wuffs_base__color_ycc__as__color_u32(*up0++, *up1++, *up2++));
+ }
+ }
+}
+
+static void //
+wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter(
+ wuffs_base__pixel_buffer* dst,
uint32_t width,
uint32_t height,
const uint8_t* src_ptr0,
@@ -22696,74 +22925,129 @@
uint32_t stride0,
uint32_t stride1,
uint32_t stride2,
- uint32_t h0_out_of_12,
- uint32_t h1_out_of_12,
- uint32_t h2_out_of_12,
- uint32_t v0_out_of_12,
- uint32_t v1_out_of_12,
- uint32_t v2_out_of_12) {
- uint32_t iy0 = 0;
- uint32_t iy1 = 0;
- uint32_t iy2 = 0;
- uint32_t y = 0;
+ uint32_t inv_h0,
+ uint32_t inv_h1,
+ uint32_t inv_h2,
+ uint32_t inv_v0,
+ uint32_t inv_v1,
+ uint32_t inv_v2,
+ uint32_t half_width_for_2to1,
+ uint32_t half_height_for_2to1,
+ uint8_t* scratch_buffer_2k_ptr) {
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0 =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs
+ [(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1 =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs
+ [(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2 =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs
+ [(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
+
+ uint32_t y;
+ for (y = 0u; y < height; y++) {
+ wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter_single_row(
+ dst, width, y, //
+ 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, //
+ 0u, //
+ scratch_buffer_2k_ptr, //
+ upfunc0, upfunc1, upfunc2);
+ }
+}
+
+static void //
+wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
+ wuffs_base__pixel_buffer* dst,
+ uint32_t width,
+ uint32_t height,
+ const uint8_t* src_ptr0,
+ const uint8_t* src_ptr1,
+ const uint8_t* src_ptr2,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t inv_h0,
+ uint32_t inv_h1,
+ uint32_t inv_h2,
+ uint32_t inv_v0,
+ uint32_t inv_v1,
+ uint32_t inv_v2) {
+ // Convert an inv_h or inv_v value from {1, 2, 3, 4} to {12, 6, 4, 3}.
+ uint32_t h0_out_of_12 = 12u / inv_h0;
+ uint32_t h1_out_of_12 = 12u / inv_h1;
+ uint32_t h2_out_of_12 = 12u / inv_h2;
+ uint32_t v0_out_of_12 = 12u / inv_v0;
+ uint32_t v1_out_of_12 = 12u / inv_v1;
+ uint32_t v2_out_of_12 = 12u / inv_v2;
+
+ uint32_t iy0 = 0u;
+ uint32_t iy1 = 0u;
+ uint32_t iy2 = 0u;
+ uint32_t y = 0u;
while (true) {
const uint8_t* src_iter0 = src_ptr0;
const uint8_t* src_iter1 = src_ptr1;
const uint8_t* src_iter2 = src_ptr2;
- uint32_t ix0 = 0;
- uint32_t ix1 = 0;
- uint32_t ix2 = 0;
- uint32_t x = 0;
+ uint32_t ix0 = 0u;
+ uint32_t ix1 = 0u;
+ uint32_t ix2 = 0u;
+ uint32_t x = 0u;
while (true) {
wuffs_base__pixel_buffer__set_color_u32_at(
dst, x, y,
wuffs_base__color_ycc__as__color_u32(*src_iter0, *src_iter1,
*src_iter2));
- if ((x + 1) == width) {
+ if ((x + 1u) == width) {
break;
}
- x = x + 1;
+ x = x + 1u;
ix0 += h0_out_of_12;
- if (ix0 >= 12) {
- ix0 = 0;
+ if (ix0 >= 12u) {
+ ix0 = 0u;
src_iter0++;
}
ix1 += h1_out_of_12;
- if (ix1 >= 12) {
- ix1 = 0;
+ if (ix1 >= 12u) {
+ ix1 = 0u;
src_iter1++;
}
ix2 += h2_out_of_12;
- if (ix2 >= 12) {
- ix2 = 0;
+ if (ix2 >= 12u) {
+ ix2 = 0u;
src_iter2++;
}
}
- if ((y + 1) == height) {
+ if ((y + 1u) == height) {
break;
}
- y = y + 1;
+ y = y + 1u;
iy0 += v0_out_of_12;
- if (iy0 >= 12) {
- iy0 = 0;
+ if (iy0 >= 12u) {
+ iy0 = 0u;
src_ptr0 += stride0;
}
iy1 += v1_out_of_12;
- if (iy1 >= 12) {
- iy1 = 0;
+ if (iy1 >= 12u) {
+ iy1 = 0u;
src_ptr1 += stride1;
}
iy2 += v2_out_of_12;
- if (iy2 >= 12) {
- iy2 = 0;
+ if (iy2 >= 12u) {
+ iy2 = 0u;
src_ptr2 += stride2;
}
}
}
+// --------
+
// wuffs_base__pixel_swizzler__flattened_length is like
// wuffs_base__table__flattened_length but returns uint64_t (not size_t) and
// also accounts for subsampling.
@@ -22773,66 +23057,78 @@
uint32_t stride,
uint32_t inv_h,
uint32_t inv_v) {
- uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1)) / inv_h;
- uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1)) / inv_v;
- if (scaled_height <= 0) {
- return 0;
+ uint64_t scaled_width = (((uint64_t)width) + (inv_h - 1u)) / inv_h;
+ uint64_t scaled_height = (((uint64_t)height) + (inv_v - 1u)) / inv_v;
+ if (scaled_height <= 0u) {
+ return 0u;
}
- return ((scaled_height - 1) * stride) + scaled_width;
+ return ((scaled_height - 1u) * stride) + scaled_width;
}
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
-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,
- wuffs_base__slice_u8 src0,
- wuffs_base__slice_u8 src1,
- wuffs_base__slice_u8 src2,
- wuffs_base__slice_u8 src3,
- uint32_t width0,
- uint32_t width1,
- uint32_t width2,
- uint32_t width3,
- uint32_t height0,
- uint32_t height1,
- uint32_t height2,
- uint32_t height3,
- uint32_t stride0,
- uint32_t stride1,
- uint32_t stride2,
- uint32_t stride3,
- uint8_t h0,
- uint8_t h1,
- uint8_t h2,
- uint8_t h3,
- uint8_t v0,
- uint8_t v1,
- uint8_t v2,
- uint8_t v3,
- bool triangle_filter_for_2to1) {
+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,
+ wuffs_base__slice_u8 src0,
+ wuffs_base__slice_u8 src1,
+ wuffs_base__slice_u8 src2,
+ wuffs_base__slice_u8 src3,
+ uint32_t width0,
+ uint32_t width1,
+ uint32_t width2,
+ uint32_t width3,
+ uint32_t height0,
+ uint32_t height1,
+ uint32_t height2,
+ uint32_t height3,
+ uint32_t stride0,
+ uint32_t stride1,
+ uint32_t stride2,
+ uint32_t stride3,
+ uint8_t h0,
+ uint8_t h1,
+ uint8_t h2,
+ uint8_t h3,
+ uint8_t v0,
+ uint8_t v1,
+ uint8_t v2,
+ uint8_t v3,
+ bool triangle_filter_for_2to1,
+ wuffs_base__slice_u8 scratch_buffer_2k) {
if (!p) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
- } else if ((h3 != 0) || (v3 != 0) || triangle_filter_for_2to1) {
- // TODO: support the K in YCCK and support triangle_filter_for_2to1.
+ } else if ((h3 != 0u) || (v3 != 0u)) {
+ // TODO: support the K in YCCK.
return wuffs_base__make_status(
wuffs_base__error__unsupported_pixel_swizzler_option);
- } else if (!dst || (width > 0xFFFF) || (height > 0xFFFF) || //
- (4 <= (h0 - 1)) || (4 <= (v0 - 1)) || //
- (4 <= (h1 - 1)) || (4 <= (v1 - 1)) || //
- (4 <= (h2 - 1)) || (4 <= (v2 - 1))) {
+ } else if (!dst || (width > 0xFFFFu) || (height > 0xFFFFu) || //
+ (4u <= (h0 - 1u)) || (4u <= (v0 - 1u)) || //
+ (4u <= (h1 - 1u)) || (4u <= (v1 - 1u)) || //
+ (4u <= (h2 - 1u)) || (4u <= (v2 - 1u)) || //
+ (scratch_buffer_2k.len < 2048u)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
uint32_t max_incl_h = wuffs_base__u32__max_of_4(h0, h1, h2, h3);
uint32_t max_incl_v = wuffs_base__u32__max_of_4(v0, v1, v2, v3);
+
+ // Calculate the inverse h and v ratios.
+ //
+ // It also canonicalizes (h=2 and max_incl_h=4) as equivalent to (h=1 and
+ // max_incl_h=2). In both cases, the inv_h value is 2.
uint32_t inv_h0 = max_incl_h / h0;
uint32_t inv_h1 = max_incl_h / h1;
uint32_t inv_h2 = max_incl_h / h2;
uint32_t inv_v0 = max_incl_v / v0;
uint32_t inv_v1 = max_incl_v / v1;
uint32_t inv_v2 = max_incl_v / v2;
+
+ uint32_t half_width_for_2to1 = (width + 1u) / 2u;
+ uint32_t half_height_for_2to1 = (height + 1u) / 2u;
+
width = wuffs_base__u32__min_of_5( //
width, //
width0 * inv_h0, //
@@ -22892,20 +23188,32 @@
wuffs_base__error__unsupported_pixel_swizzler_option);
}
- if ((width <= 0) || (height <= 0)) {
+ if ((width <= 0u) || (height <= 0u)) {
return wuffs_base__make_status(NULL);
}
- wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
- p, dst, dst_palette, width, height, //
- src0.ptr, src1.ptr, src2.ptr, //
- stride0, stride1, stride2, //
- (h0 * 12) / max_incl_h, //
- (h1 * 12) / max_incl_h, //
- (h2 * 12) / max_incl_h, //
- (v0 * 12) / max_incl_v, //
- (v1 * 12) / max_incl_v, //
- (v2 * 12) / max_incl_v);
+ if (triangle_filter_for_2to1 &&
+ (wuffs_base__pixel_swizzler__has_triangle_upsampler(inv_h0, inv_v0) ||
+ wuffs_base__pixel_swizzler__has_triangle_upsampler(inv_h1, inv_v1) ||
+ wuffs_base__pixel_swizzler__has_triangle_upsampler(inv_h2, inv_v2))) {
+ wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter(
+ 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, //
+ scratch_buffer_2k.ptr);
+
+ } else {
+ wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
+ dst, width, height, //
+ src0.ptr, src1.ptr, src2.ptr, //
+ stride0, stride1, stride2, //
+ inv_h0, inv_h1, inv_h2, //
+ inv_v0, inv_v1, inv_v2);
+ }
+
return wuffs_base__make_status(NULL);
}
@@ -37757,6 +38065,7 @@
bool v_has_h3 = false;
bool v_has_v24 = false;
bool v_has_v3 = false;
+ uint32_t v_upper_bound = 0;
const uint8_t* iop_a_src = NULL;
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
@@ -37988,28 +38297,15 @@
} else {
self->private_impl.f_height_in_mcus = ((self->private_impl.f_height + 31) / 32);
}
- v_i = 0;
- while (v_i < self->private_impl.f_num_components) {
- if (self->private_impl.f_components_h[v_i] == 1) {
- self->private_impl.f_components_workbuf_widths[v_i] = (((self->private_impl.f_width + 7) / 8) * 8);
- } else if (self->private_impl.f_components_h[v_i] == 2) {
- self->private_impl.f_components_workbuf_widths[v_i] = (((self->private_impl.f_width + 15) / 16) * 16);
- } else if (self->private_impl.f_components_h[v_i] == 3) {
- self->private_impl.f_components_workbuf_widths[v_i] = (((self->private_impl.f_width + 23) / 24) * 24);
- } else {
- self->private_impl.f_components_workbuf_widths[v_i] = (((self->private_impl.f_width + 31) / 32) * 32);
- }
- if (self->private_impl.f_components_v[v_i] == 1) {
- self->private_impl.f_components_workbuf_heights[v_i] = (((self->private_impl.f_height + 7) / 8) * 8);
- } else if (self->private_impl.f_components_v[v_i] == 2) {
- self->private_impl.f_components_workbuf_heights[v_i] = (((self->private_impl.f_height + 15) / 16) * 16);
- } else if (self->private_impl.f_components_v[v_i] == 3) {
- self->private_impl.f_components_workbuf_heights[v_i] = (((self->private_impl.f_height + 23) / 24) * 24);
- } else {
- self->private_impl.f_components_workbuf_heights[v_i] = (((self->private_impl.f_height + 31) / 32) * 32);
- }
- v_i += 1;
- }
+ v_upper_bound = 65544;
+ self->private_impl.f_components_workbuf_widths[0] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_width_in_mcus * ((uint32_t)(self->private_impl.f_components_h[0]))));
+ self->private_impl.f_components_workbuf_widths[1] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_width_in_mcus * ((uint32_t)(self->private_impl.f_components_h[1]))));
+ self->private_impl.f_components_workbuf_widths[2] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_width_in_mcus * ((uint32_t)(self->private_impl.f_components_h[2]))));
+ self->private_impl.f_components_workbuf_widths[3] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_width_in_mcus * ((uint32_t)(self->private_impl.f_components_h[3]))));
+ self->private_impl.f_components_workbuf_heights[0] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_height_in_mcus * ((uint32_t)(self->private_impl.f_components_v[0]))));
+ self->private_impl.f_components_workbuf_heights[1] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_height_in_mcus * ((uint32_t)(self->private_impl.f_components_v[1]))));
+ self->private_impl.f_components_workbuf_heights[2] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_height_in_mcus * ((uint32_t)(self->private_impl.f_components_v[2]))));
+ self->private_impl.f_components_workbuf_heights[3] = wuffs_base__u32__min(v_upper_bound, (8 * self->private_impl.f_height_in_mcus * ((uint32_t)(self->private_impl.f_components_v[3]))));
self->private_impl.f_components_workbuf_offsets[0] = 0;
self->private_impl.f_components_workbuf_offsets[1] = (self->private_impl.f_components_workbuf_offsets[0] + (((uint64_t)(self->private_impl.f_components_workbuf_widths[0])) * ((uint64_t)(self->private_impl.f_components_workbuf_heights[0]))));
self->private_impl.f_components_workbuf_offsets[2] = (self->private_impl.f_components_workbuf_offsets[1] + (((uint64_t)(self->private_impl.f_components_workbuf_widths[1])) * ((uint64_t)(self->private_impl.f_components_workbuf_heights[1]))));
@@ -39419,7 +39715,8 @@
self->private_impl.f_components_v[1],
self->private_impl.f_components_v[2],
self->private_impl.f_components_v[3],
- false);
+ true,
+ wuffs_base__make_slice_u8(self->private_data.f_bitstream_buffer, 2048));
return wuffs_base__status__ensure_not_a_suspension(v_status);
}
diff --git a/std/jpeg/decode_jpeg.wuffs b/std/jpeg/decode_jpeg.wuffs
index 65a4461..c3bcaae 100644
--- a/std/jpeg/decode_jpeg.wuffs
+++ b/std/jpeg/decode_jpeg.wuffs
@@ -366,16 +366,19 @@
}
pri func decoder.decode_sof?(src: base.io_reader) {
- var c : base.u8
- var comp_h : base.u8
- var comp_v : base.u8
- var i : base.u32
- var j : base.u32
+ var c : base.u8
+ var comp_h : base.u8
+ var comp_v : base.u8
+ var i : base.u32
+ var j : base.u32
+
var has_h24 : base.bool
var has_h3 : base.bool
var has_v24 : base.bool
var has_v3 : base.bool
+ var upper_bound : base.u32[..= 0x1_0008]
+
if this.payload_length < 6 {
return "#bad SOF marker"
}
@@ -498,32 +501,25 @@
this.height_in_mcus = (this.height + 0x1F) / 0x20
}
- i = 0
- while i < this.num_components {
- assert i < 4 via "a < b: a < c; c <= b"(c: this.num_components)
+ upper_bound = 0x1_0008
- if this.components_h[i] == 1 {
- this.components_workbuf_widths[i] = ((this.width + 0x07) / 0x08) * 0x08
- } else if this.components_h[i] == 2 {
- this.components_workbuf_widths[i] = ((this.width + 0x0F) / 0x10) * 0x10
- } else if this.components_h[i] == 3 {
- this.components_workbuf_widths[i] = ((this.width + 0x17) / 0x18) * 0x18
- } else {
- this.components_workbuf_widths[i] = ((this.width + 0x1F) / 0x20) * 0x20
- }
+ this.components_workbuf_widths[0] = upper_bound.min(no_more_than:
+ 8 * this.width_in_mcus * (this.components_h[0] as base.u32))
+ this.components_workbuf_widths[1] = upper_bound.min(no_more_than:
+ 8 * this.width_in_mcus * (this.components_h[1] as base.u32))
+ this.components_workbuf_widths[2] = upper_bound.min(no_more_than:
+ 8 * this.width_in_mcus * (this.components_h[2] as base.u32))
+ this.components_workbuf_widths[3] = upper_bound.min(no_more_than:
+ 8 * this.width_in_mcus * (this.components_h[3] as base.u32))
- if this.components_v[i] == 1 {
- this.components_workbuf_heights[i] = ((this.height + 0x07) / 0x08) * 0x08
- } else if this.components_v[i] == 2 {
- this.components_workbuf_heights[i] = ((this.height + 0x0F) / 0x10) * 0x10
- } else if this.components_v[i] == 3 {
- this.components_workbuf_heights[i] = ((this.height + 0x17) / 0x18) * 0x18
- } else {
- this.components_workbuf_heights[i] = ((this.height + 0x1F) / 0x20) * 0x20
- }
-
- i += 1
- } endwhile
+ this.components_workbuf_heights[0] = upper_bound.min(no_more_than:
+ 8 * this.height_in_mcus * (this.components_v[0] as base.u32))
+ this.components_workbuf_heights[1] = upper_bound.min(no_more_than:
+ 8 * this.height_in_mcus * (this.components_v[1] as base.u32))
+ this.components_workbuf_heights[2] = upper_bound.min(no_more_than:
+ 8 * this.height_in_mcus * (this.components_v[2] as base.u32))
+ this.components_workbuf_heights[3] = upper_bound.min(no_more_than:
+ 8 * this.height_in_mcus * (this.components_v[3] as base.u32))
this.components_workbuf_offsets[0] = 0
this.components_workbuf_offsets[1] = this.components_workbuf_offsets[0] +
@@ -1437,7 +1433,8 @@
v1: this.components_v[1],
v2: this.components_v[2],
v3: this.components_v[3],
- triangle_filter_for_2to1: false)
+ triangle_filter_for_2to1: true,
+ scratch_buffer_2k: this.bitstream_buffer[..])
return status
}
diff --git a/test/c/std/wbmp.c b/test/c/std/wbmp.c
index 640d60d..7090e03 100644
--- a/test/c/std/wbmp.c
+++ b/test/c/std/wbmp.c
@@ -512,6 +512,36 @@
return NULL;
}
+const char* //
+test_wuffs_upsample_inv_h2v1() {
+ CHECK_FOCUS(__func__);
+
+ // src_array0 is "A lovely example".
+ const uint8_t src_array0[16] = {
+ 0x41, 0x20, 0x6C, 0x6F, 0x76, 0x65, 0x6C, 0x79, //
+ 0x20, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, //
+ };
+
+ const uint8_t want_array[32] = {
+ 0x41, 0x41, 0x20, 0x20, 0x6C, 0x6C, 0x6F, 0x6F, //
+ 0x76, 0x76, 0x65, 0x65, 0x6C, 0x6C, 0x79, 0x79, //
+ 0x20, 0x20, 0x65, 0x65, 0x78, 0x78, 0x61, 0x61, //
+ 0x6D, 0x6D, 0x70, 0x70, 0x6C, 0x6C, 0x65, 0x65, //
+ };
+
+ const uint8_t* have_ptr =
+ wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2vn_box(
+ g_have_array_u8, src_array0, src_array0, 16, 0, true, true);
+
+ const bool closed = true;
+ wuffs_base__io_buffer have = wuffs_base__ptr_u8__reader( //
+ (void*)have_ptr, 32, closed);
+ wuffs_base__io_buffer want = wuffs_base__ptr_u8__reader( //
+ (void*)want_array, 32, closed);
+
+ return check_io_buffers_equal("", &have, &want);
+}
+
// ---------------- WBMP Tests
const char* //
@@ -769,6 +799,7 @@
test_wuffs_color_ycc_as_color_u32,
test_wuffs_pixel_buffer_fill_rect,
test_wuffs_pixel_swizzler_swizzle,
+ test_wuffs_upsample_inv_h2v1,
test_wuffs_wbmp_decode_frame_config,
test_wuffs_wbmp_decode_image_config,
