mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-21 16:47:28 +01:00
std/jpeg: prepare for triangle-filter upsampling
This commit is contained in:
1 parent
56fae16567
commit
94df43c530
7 files changed
+926
-290
No files matched your search
@@ -12733,36 +12733,38 @@ wuffs_base__pixel_swizzler__swizzle_interleaved_transparent_black(
|
||||
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 @@ wuffs_base__u32__min_of_5(uint32_t a,
|
||||
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,
|
||||
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,
|
||||
wuffs_base__slice_u8 dst_palette,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
const uint8_t* src_ptr0,
|
||||
@@ -22696,74 +22925,129 @@ wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter(
|
||||
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 @@ wuffs_base__pixel_swizzler__flattened_length(uint32_t width,
|
||||
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__pixel_swizzler__swizzle_ycck(const wuffs_base__pixel_swizzler* p,
|
||||
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 @@ wuffs_jpeg__decoder__decode_sof(
|
||||
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 @@ wuffs_jpeg__decoder__decode_sof(
|
||||
} 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 @@ wuffs_jpeg__decoder__swizzle_colorful(
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user