mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
1349 lines
47 KiB
C
1349 lines
47 KiB
C
// Copyright 2023 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
// --------
|
|
|
|
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
|
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_bgrx_x86_avx2(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2);
|
|
|
|
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_rgbx_x86_avx2(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2);
|
|
|
|
#if defined(__GNUC__) && !defined(__clang__)
|
|
// No-op.
|
|
#else
|
|
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
|
|
static const uint8_t* //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
|
uint8_t* dst_ptr,
|
|
const uint8_t* src_ptr_major,
|
|
const uint8_t* src_ptr_minor,
|
|
size_t src_len,
|
|
uint32_t h1v2_bias_ignored,
|
|
bool first_column,
|
|
bool last_column);
|
|
#endif
|
|
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
|
|
|
// --------
|
|
|
|
static inline uint32_t //
|
|
wuffs_base__u32__max_of_4(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
|
|
return wuffs_base__u32__max( //
|
|
wuffs_base__u32__max(a, b), //
|
|
wuffs_base__u32__max(c, d));
|
|
}
|
|
|
|
static inline uint32_t //
|
|
wuffs_base__u32__min_of_5(uint32_t a,
|
|
uint32_t b,
|
|
uint32_t c,
|
|
uint32_t d,
|
|
uint32_t e) {
|
|
return wuffs_base__u32__min( //
|
|
wuffs_base__u32__min( //
|
|
wuffs_base__u32__min(a, b), //
|
|
wuffs_base__u32__min(c, d)), //
|
|
e);
|
|
}
|
|
|
|
// --------
|
|
|
|
typedef void (*wuffs_base__pixel_swizzler__swizzle_ycc__convert_4_func)(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2,
|
|
const uint8_t* up3);
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_cmyk__convert_4_general(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2,
|
|
const uint8_t* up3) {
|
|
for (; x < x_end; x++) {
|
|
// It's called CMYK but, but for Adobe CMYK JPEG images in practice, it's
|
|
// RGBW: 0xFFu means no ink instead of full ink. Note that a double
|
|
// inversion is a no-op, so inversions might be implicit in the code below.
|
|
uint32_t r = ((uint32_t)(*up0++));
|
|
uint32_t g = ((uint32_t)(*up1++));
|
|
uint32_t b = ((uint32_t)(*up2++));
|
|
uint32_t w = ((uint32_t)(*up3++));
|
|
r = ((r * w) + 0x7Fu) / 0xFFu;
|
|
g = ((g * w) + 0x7Fu) / 0xFFu;
|
|
b = ((b * w) + 0x7Fu) / 0xFFu;
|
|
wuffs_base__pixel_buffer__set_color_u32_at(
|
|
dst, x, y, 0xFF000000u | (r << 16u) | (g << 8u) | (b << 0u));
|
|
}
|
|
}
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycck__convert_4_general(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2,
|
|
const uint8_t* up3) {
|
|
for (; x < x_end; x++) {
|
|
// We invert once again: 0xFFu means no ink instead of full ink.
|
|
uint32_t color = //
|
|
wuffs_base__color_ycc__as__color_u32( //
|
|
*up0++, *up1++, *up2++);
|
|
uint32_t r = 0xFFu - (0xFFu & (color >> 16u));
|
|
uint32_t g = 0xFFu - (0xFFu & (color >> 8u));
|
|
uint32_t b = 0xFFu - (0xFFu & (color >> 0u));
|
|
uint32_t w = ((uint32_t)(*up3++));
|
|
r = ((r * w) + 0x7Fu) / 0xFFu;
|
|
g = ((g * w) + 0x7Fu) / 0xFFu;
|
|
b = ((b * w) + 0x7Fu) / 0xFFu;
|
|
wuffs_base__pixel_buffer__set_color_u32_at(
|
|
dst, x, y, 0xFF000000u | (r << 16u) | (g << 8u) | (b << 0u));
|
|
}
|
|
}
|
|
|
|
// --------
|
|
|
|
typedef void (*wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_func)(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2);
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_rgb__convert_3_general(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2) {
|
|
for (; x < x_end; x++) {
|
|
uint32_t color = 0xFF000000u | //
|
|
(((uint32_t)(*up0++)) << 16u) | //
|
|
(((uint32_t)(*up1++)) << 8u) | //
|
|
(((uint32_t)(*up2++)) << 0u);
|
|
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
|
|
}
|
|
}
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_general(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2) {
|
|
for (; x < x_end; x++) {
|
|
uint32_t color = //
|
|
wuffs_base__color_ycc__as__color_u32( //
|
|
*up0++, *up1++, *up2++);
|
|
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
|
|
}
|
|
}
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_bgrx(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2) {
|
|
size_t dst_stride = dst->private_impl.planes[0].stride;
|
|
uint8_t* dst_iter = dst->private_impl.planes[0].ptr +
|
|
(dst_stride * ((size_t)y)) + (4u * ((size_t)x));
|
|
|
|
for (; x < x_end; x++) {
|
|
uint32_t color = //
|
|
wuffs_base__color_ycc__as__color_u32( //
|
|
*up0++, *up1++, *up2++);
|
|
wuffs_base__poke_u32le__no_bounds_check(dst_iter, color);
|
|
dst_iter += 4u;
|
|
}
|
|
}
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_rgbx(
|
|
wuffs_base__pixel_buffer* dst,
|
|
uint32_t x,
|
|
uint32_t x_end,
|
|
uint32_t y,
|
|
const uint8_t* up0,
|
|
const uint8_t* up1,
|
|
const uint8_t* up2) {
|
|
size_t dst_stride = dst->private_impl.planes[0].stride;
|
|
uint8_t* dst_iter = dst->private_impl.planes[0].ptr +
|
|
(dst_stride * ((size_t)y)) + (4u * ((size_t)x));
|
|
|
|
for (; x < x_end; x++) {
|
|
uint32_t color = //
|
|
wuffs_base__color_ycc__as__color_u32_abgr( //
|
|
*up0++, *up1++, *up2++);
|
|
wuffs_base__poke_u32le__no_bounds_check(dst_iter, color);
|
|
dst_iter += 4u;
|
|
}
|
|
}
|
|
|
|
// --------
|
|
|
|
// 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.
|
|
//
|
|
// Triangle filters use a 3:1 ratio (in 1 dimension), or 9:3:3:1 (in 2
|
|
// dimensions), which is higher quality (less blocky) but also higher
|
|
// computational effort.
|
|
//
|
|
// In theory, we could use triangle filters for any (inv_h, inv_v) combination.
|
|
// In practice, matching libjpeg-turbo, we only implement it for the common
|
|
// chroma subsampling ratios (YCC420, YCC422 or YCC440), corresponding to an
|
|
// (inv_h, inv_v) pair of (2, 2), (2, 1) or (1, 2).
|
|
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;
|
|
}
|
|
|
|
static const uint8_t* //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1v2_triangle(
|
|
uint8_t* dst_ptr,
|
|
const uint8_t* src_ptr_major,
|
|
const uint8_t* src_ptr_minor,
|
|
size_t src_len,
|
|
uint32_t h1v2_bias,
|
|
bool first_column,
|
|
bool last_column) {
|
|
uint8_t* dp = dst_ptr;
|
|
const uint8_t* sp_major = src_ptr_major;
|
|
const uint8_t* sp_minor = src_ptr_minor;
|
|
while (src_len--) {
|
|
*dp++ = (uint8_t)(((3u * ((uint32_t)(*sp_major++))) + //
|
|
(1u * ((uint32_t)(*sp_minor++))) + //
|
|
h1v2_bias) >>
|
|
2u);
|
|
}
|
|
return dst_ptr;
|
|
}
|
|
|
|
static const uint8_t* //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2v1_triangle(
|
|
uint8_t* dst_ptr,
|
|
const uint8_t* src_ptr_major,
|
|
const uint8_t* src_ptr_minor,
|
|
size_t src_len,
|
|
uint32_t h1v2_bias_ignored,
|
|
bool first_column,
|
|
bool last_column) {
|
|
uint8_t* dp = dst_ptr;
|
|
const uint8_t* sp = src_ptr_major;
|
|
|
|
if (first_column) {
|
|
src_len--;
|
|
if ((src_len <= 0u) && last_column) {
|
|
uint8_t sv = *sp++;
|
|
*dp++ = sv;
|
|
*dp++ = sv;
|
|
return dst_ptr;
|
|
}
|
|
uint32_t svp1 = sp[+1];
|
|
uint8_t sv = *sp++;
|
|
*dp++ = sv;
|
|
*dp++ = (uint8_t)(((3u * (uint32_t)sv) + svp1 + 2u) >> 2u);
|
|
if (src_len <= 0u) {
|
|
return dst_ptr;
|
|
}
|
|
}
|
|
|
|
if (last_column) {
|
|
src_len--;
|
|
}
|
|
|
|
for (; src_len > 0u; src_len--) {
|
|
uint32_t svm1 = sp[-1];
|
|
uint32_t svp1 = sp[+1];
|
|
uint32_t sv3 = 3u * (uint32_t)(*sp++);
|
|
*dp++ = (uint8_t)((sv3 + svm1 + 1u) >> 2u);
|
|
*dp++ = (uint8_t)((sv3 + svp1 + 2u) >> 2u);
|
|
}
|
|
|
|
if (last_column) {
|
|
uint32_t svm1 = sp[-1];
|
|
uint8_t sv = *sp++;
|
|
*dp++ = (uint8_t)(((3u * (uint32_t)sv) + svm1 + 1u) >> 2u);
|
|
*dp++ = sv;
|
|
}
|
|
|
|
return dst_ptr;
|
|
}
|
|
|
|
static const uint8_t* //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2v2_triangle(
|
|
uint8_t* dst_ptr,
|
|
const uint8_t* src_ptr_major,
|
|
const uint8_t* src_ptr_minor,
|
|
size_t src_len,
|
|
uint32_t h1v2_bias_ignored,
|
|
bool first_column,
|
|
bool last_column) {
|
|
uint8_t* dp = dst_ptr;
|
|
const uint8_t* sp_major = src_ptr_major;
|
|
const uint8_t* sp_minor = src_ptr_minor;
|
|
|
|
if (first_column) {
|
|
src_len--;
|
|
if ((src_len <= 0u) && last_column) {
|
|
uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + //
|
|
(4u * ((uint32_t)(*sp_minor++)));
|
|
*dp++ = (uint8_t)((sv + 8u) >> 4u);
|
|
*dp++ = (uint8_t)((sv + 7u) >> 4u);
|
|
return dst_ptr;
|
|
}
|
|
|
|
uint32_t sv_major_m1 = sp_major[-0]; // Clamp offset to zero.
|
|
uint32_t sv_minor_m1 = sp_minor[-0]; // Clamp offset to zero.
|
|
uint32_t sv_major_p1 = sp_major[+1];
|
|
uint32_t sv_minor_p1 = sp_minor[+1];
|
|
|
|
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
|
(3u * ((uint32_t)(*sp_minor++)));
|
|
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
|
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
|
if (src_len <= 0u) {
|
|
return dst_ptr;
|
|
}
|
|
}
|
|
|
|
if (last_column) {
|
|
src_len--;
|
|
}
|
|
|
|
for (; src_len > 0u; src_len--) {
|
|
uint32_t sv_major_m1 = sp_major[-1];
|
|
uint32_t sv_minor_m1 = sp_minor[-1];
|
|
uint32_t sv_major_p1 = sp_major[+1];
|
|
uint32_t sv_minor_p1 = sp_minor[+1];
|
|
|
|
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
|
(3u * ((uint32_t)(*sp_minor++)));
|
|
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
|
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
|
}
|
|
|
|
if (last_column) {
|
|
uint32_t sv_major_m1 = sp_major[-1];
|
|
uint32_t sv_minor_m1 = sp_minor[-1];
|
|
uint32_t sv_major_p1 = sp_major[+0]; // Clamp offset to zero.
|
|
uint32_t sv_minor_p1 = sp_minor[+0]; // Clamp offset to zero.
|
|
|
|
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
|
(3u * ((uint32_t)(*sp_minor++)));
|
|
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
|
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
|
}
|
|
|
|
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_ycck__general__triangle_filter_edge_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,
|
|
const uint8_t* src_ptr3,
|
|
uint32_t stride0,
|
|
uint32_t stride1,
|
|
uint32_t stride2,
|
|
uint32_t stride3,
|
|
uint32_t inv_h0,
|
|
uint32_t inv_h1,
|
|
uint32_t inv_h2,
|
|
uint32_t inv_h3,
|
|
uint32_t inv_v0,
|
|
uint32_t inv_v1,
|
|
uint32_t inv_v2,
|
|
uint32_t inv_v3,
|
|
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,
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc3,
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_4_func conv4func) {
|
|
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);
|
|
const uint8_t* src3 = src_ptr3 + ((y / inv_v3) * (size_t)stride3);
|
|
uint32_t total_src_len0 = 0u;
|
|
uint32_t total_src_len1 = 0u;
|
|
uint32_t total_src_len2 = 0u;
|
|
uint32_t total_src_len3 = 0u;
|
|
|
|
uint32_t x = 0u;
|
|
while (x < width) {
|
|
bool first_column = x == 0u;
|
|
uint32_t end = x + 480u;
|
|
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;
|
|
uint32_t src_len3 = ((end - x) + inv_h3 - 1u) / inv_h3;
|
|
total_src_len0 += src_len0;
|
|
total_src_len1 += src_len1;
|
|
total_src_len2 += src_len2;
|
|
total_src_len3 += src_len3;
|
|
|
|
const uint8_t* src_ptr_x0 = src0 + (x / inv_h0);
|
|
const uint8_t* up0 = (*upfunc0)( //
|
|
scratch_buffer_2k_ptr + (0u * 480u), //
|
|
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 * 480u), //
|
|
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 * 480u), //
|
|
src_ptr_x2, //
|
|
src_ptr_x2, //
|
|
src_len2, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len2 >= half_width_for_2to1));
|
|
|
|
const uint8_t* src_ptr_x3 = src3 + (x / inv_h3);
|
|
const uint8_t* up3 = (*upfunc3)( //
|
|
scratch_buffer_2k_ptr + (3u * 480u), //
|
|
src_ptr_x3, //
|
|
src_ptr_x3, //
|
|
src_len3, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len3 >= half_width_for_2to1));
|
|
|
|
(*conv4func)(dst, x, end, y, up0, up1, up2, up3);
|
|
x = end;
|
|
}
|
|
}
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycck__general__triangle_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,
|
|
const uint8_t* src_ptr3,
|
|
uint32_t stride0,
|
|
uint32_t stride1,
|
|
uint32_t stride2,
|
|
uint32_t stride3,
|
|
uint32_t inv_h0,
|
|
uint32_t inv_h1,
|
|
uint32_t inv_h2,
|
|
uint32_t inv_h3,
|
|
uint32_t inv_v0,
|
|
uint32_t inv_v1,
|
|
uint32_t inv_v2,
|
|
uint32_t inv_v3,
|
|
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 (*upfuncs)[4][4],
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_4_func conv4func) {
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0 =
|
|
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1 =
|
|
(*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2 =
|
|
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc3 =
|
|
(*upfuncs)[(inv_h3 - 1u) & 3u][(inv_v3 - 1u) & 3u];
|
|
|
|
// First row.
|
|
uint32_t h1v2_bias = 1u;
|
|
wuffs_base__pixel_swizzler__swizzle_ycck__general__triangle_filter_edge_row(
|
|
dst, width, 0u, //
|
|
src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
|
|
stride0, stride1, stride2, stride3, //
|
|
inv_h0, inv_h1, inv_h2, inv_h3, //
|
|
inv_v0, inv_v1, inv_v2, inv_v3, //
|
|
half_width_for_2to1, //
|
|
h1v2_bias, //
|
|
scratch_buffer_2k_ptr, //
|
|
upfunc0, upfunc1, upfunc2, upfunc3, conv4func);
|
|
h1v2_bias = 2u;
|
|
|
|
// Middle rows.
|
|
bool last_row = height == 2u * half_height_for_2to1;
|
|
uint32_t y_max_excl = last_row ? (height - 1u) : height;
|
|
uint32_t y;
|
|
for (y = 1u; y < 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)
|
|
? src0_major
|
|
: ((y & 1u) ? (src0_major + stride0) : (src0_major - stride0));
|
|
const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1);
|
|
const uint8_t* src1_minor =
|
|
(inv_v1 != 2u)
|
|
? src1_major
|
|
: ((y & 1u) ? (src1_major + stride1) : (src1_major - stride1));
|
|
const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2);
|
|
const uint8_t* src2_minor =
|
|
(inv_v2 != 2u)
|
|
? src2_major
|
|
: ((y & 1u) ? (src2_major + stride2) : (src2_major - stride2));
|
|
const uint8_t* src3_major = src_ptr3 + ((y / inv_v3) * (size_t)stride3);
|
|
const uint8_t* src3_minor =
|
|
(inv_v3 != 2u)
|
|
? src3_major
|
|
: ((y & 1u) ? (src3_major + stride3) : (src3_major - stride3));
|
|
uint32_t total_src_len0 = 0u;
|
|
uint32_t total_src_len1 = 0u;
|
|
uint32_t total_src_len2 = 0u;
|
|
uint32_t total_src_len3 = 0u;
|
|
|
|
uint32_t x = 0u;
|
|
while (x < width) {
|
|
bool first_column = x == 0u;
|
|
uint32_t end = x + 480u;
|
|
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;
|
|
uint32_t src_len3 = ((end - x) + inv_h3 - 1u) / inv_h3;
|
|
total_src_len0 += src_len0;
|
|
total_src_len1 += src_len1;
|
|
total_src_len2 += src_len2;
|
|
total_src_len3 += src_len3;
|
|
|
|
const uint8_t* up0 = (*upfunc0)( //
|
|
scratch_buffer_2k_ptr + (0u * 480u), //
|
|
src0_major + (x / inv_h0), //
|
|
src0_minor + (x / inv_h0), //
|
|
src_len0, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len0 >= half_width_for_2to1));
|
|
|
|
const uint8_t* up1 = (*upfunc1)( //
|
|
scratch_buffer_2k_ptr + (1u * 480u), //
|
|
src1_major + (x / inv_h1), //
|
|
src1_minor + (x / inv_h1), //
|
|
src_len1, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len1 >= half_width_for_2to1));
|
|
|
|
const uint8_t* up2 = (*upfunc2)( //
|
|
scratch_buffer_2k_ptr + (2u * 480u), //
|
|
src2_major + (x / inv_h2), //
|
|
src2_minor + (x / inv_h2), //
|
|
src_len2, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len2 >= half_width_for_2to1));
|
|
|
|
const uint8_t* up3 = (*upfunc3)( //
|
|
scratch_buffer_2k_ptr + (3u * 480u), //
|
|
src3_major + (x / inv_h3), //
|
|
src3_minor + (x / inv_h3), //
|
|
src_len3, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len3 >= half_width_for_2to1));
|
|
|
|
(*conv4func)(dst, x, end, y, up0, up1, up2, up3);
|
|
x = end;
|
|
}
|
|
|
|
h1v2_bias ^= 3u;
|
|
}
|
|
|
|
// Last row.
|
|
if (y_max_excl != height) {
|
|
wuffs_base__pixel_swizzler__swizzle_ycck__general__triangle_filter_edge_row(
|
|
dst, width, height - 1u, //
|
|
src_ptr0, src_ptr1, src_ptr2, src_ptr3, //
|
|
stride0, stride1, stride2, stride3, //
|
|
inv_h0, inv_h1, inv_h2, inv_h3, //
|
|
inv_v0, inv_v1, inv_v2, inv_v3, //
|
|
half_width_for_2to1, //
|
|
h1v2_bias, //
|
|
scratch_buffer_2k_ptr, //
|
|
upfunc0, upfunc1, upfunc2, upfunc3, conv4func);
|
|
}
|
|
}
|
|
|
|
static void //
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter_edge_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,
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_func conv3func) {
|
|
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));
|
|
|
|
(*conv3func)(dst, x, end, y, up0, up1, up2);
|
|
x = end;
|
|
}
|
|
}
|
|
|
|
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,
|
|
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 half_height_for_2to1,
|
|
uint8_t* scratch_buffer_2k_ptr,
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func (*upfuncs)[4][4],
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_func conv3func) {
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0 =
|
|
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1 =
|
|
(*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2 =
|
|
(*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
|
|
|
|
// First row.
|
|
uint32_t h1v2_bias = 1u;
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter_edge_row(
|
|
dst, width, 0u, //
|
|
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);
|
|
h1v2_bias = 2u;
|
|
|
|
// Middle rows.
|
|
bool last_row = height == 2u * half_height_for_2to1;
|
|
uint32_t y_max_excl = last_row ? (height - 1u) : height;
|
|
uint32_t y;
|
|
for (y = 1u; y < 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)
|
|
? src0_major
|
|
: ((y & 1u) ? (src0_major + stride0) : (src0_major - stride0));
|
|
const uint8_t* src1_major = src_ptr1 + ((y / inv_v1) * (size_t)stride1);
|
|
const uint8_t* src1_minor =
|
|
(inv_v1 != 2u)
|
|
? src1_major
|
|
: ((y & 1u) ? (src1_major + stride1) : (src1_major - stride1));
|
|
const uint8_t* src2_major = src_ptr2 + ((y / inv_v2) * (size_t)stride2);
|
|
const uint8_t* src2_minor =
|
|
(inv_v2 != 2u)
|
|
? src2_major
|
|
: ((y & 1u) ? (src2_major + stride2) : (src2_major - 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* up0 = (*upfunc0)( //
|
|
scratch_buffer_2k_ptr + (0u * 672u), //
|
|
src0_major + (x / inv_h0), //
|
|
src0_minor + (x / inv_h0), //
|
|
src_len0, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len0 >= half_width_for_2to1));
|
|
|
|
const uint8_t* up1 = (*upfunc1)( //
|
|
scratch_buffer_2k_ptr + (1u * 672u), //
|
|
src1_major + (x / inv_h1), //
|
|
src1_minor + (x / inv_h1), //
|
|
src_len1, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len1 >= half_width_for_2to1));
|
|
|
|
const uint8_t* up2 = (*upfunc2)( //
|
|
scratch_buffer_2k_ptr + (2u * 672u), //
|
|
src2_major + (x / inv_h2), //
|
|
src2_minor + (x / inv_h2), //
|
|
src_len2, //
|
|
h1v2_bias, //
|
|
first_column, //
|
|
(total_src_len2 >= half_width_for_2to1));
|
|
|
|
(*conv3func)(dst, x, end, y, up0, up1, up2);
|
|
x = end;
|
|
}
|
|
|
|
h1v2_bias ^= 3u;
|
|
}
|
|
|
|
// Last row.
|
|
if (y_max_excl != height) {
|
|
wuffs_base__pixel_swizzler__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, //
|
|
upfunc0, upfunc1, upfunc2, conv3func);
|
|
}
|
|
}
|
|
|
|
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,
|
|
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 (*upfuncs)[4][4],
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_func conv3func) {
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc0 =
|
|
(*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc1 =
|
|
(*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfunc2 =
|
|
(*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);
|
|
|
|
uint32_t x = 0u;
|
|
while (x < width) {
|
|
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;
|
|
|
|
const uint8_t* up0 = (*upfunc0)( //
|
|
scratch_buffer_2k_ptr + (0u * 672u), //
|
|
src0_major + (x / inv_h0), //
|
|
src0_major + (x / 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, //
|
|
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, //
|
|
0u, false, false);
|
|
|
|
(*conv3func)(dst, x, end, y, up0, up1, up2);
|
|
x = end;
|
|
}
|
|
}
|
|
}
|
|
|
|
// --------
|
|
|
|
// 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.
|
|
static uint64_t //
|
|
wuffs_base__pixel_swizzler__flattened_length(uint32_t width,
|
|
uint32_t height,
|
|
uint32_t stride,
|
|
uint32_t inv_h,
|
|
uint32_t inv_v) {
|
|
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 - 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 is_rgb_or_cmyk,
|
|
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 (!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)) || //
|
|
(scratch_buffer_2k.len < 2048u)) {
|
|
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
|
}
|
|
if ((h3 != 0u) || (v3 != 0u)) {
|
|
if ((4u <= ((unsigned int)h3 - 1u)) || //
|
|
(4u <= ((unsigned int)v3 - 1u))) {
|
|
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_h3 = h3 ? (max_incl_h / h3) : 0u;
|
|
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 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;
|
|
|
|
width = wuffs_base__u32__min_of_5( //
|
|
width, //
|
|
width0 * inv_h0, //
|
|
width1 * inv_h1, //
|
|
width2 * inv_h2, //
|
|
wuffs_base__pixel_config__width(&dst->pixcfg));
|
|
height = wuffs_base__u32__min_of_5( //
|
|
height, //
|
|
height0 * inv_v0, //
|
|
height1 * inv_v1, //
|
|
height2 * inv_v2, //
|
|
wuffs_base__pixel_config__height(&dst->pixcfg));
|
|
|
|
if (((h0 * inv_h0) != max_incl_h) || //
|
|
((h1 * inv_h1) != max_incl_h) || //
|
|
((h2 * inv_h2) != max_incl_h) || //
|
|
((v0 * inv_v0) != max_incl_v) || //
|
|
((v1 * inv_v1) != max_incl_v) || //
|
|
((v2 * inv_v2) != max_incl_v) || //
|
|
(src0.len < wuffs_base__pixel_swizzler__flattened_length(
|
|
width, height, stride0, inv_h0, inv_v0)) ||
|
|
(src1.len < wuffs_base__pixel_swizzler__flattened_length(
|
|
width, height, stride1, inv_h1, inv_v1)) ||
|
|
(src2.len < wuffs_base__pixel_swizzler__flattened_length(
|
|
width, height, stride2, inv_h2, inv_v2))) {
|
|
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
|
}
|
|
if ((h3 != 0u) || (v3 != 0u)) {
|
|
if (((h3 * inv_h3) != max_incl_h) || //
|
|
((v3 * inv_v3) != max_incl_v) || //
|
|
(src3.len < wuffs_base__pixel_swizzler__flattened_length(
|
|
width, height, stride3, inv_h3, inv_v3))) {
|
|
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
|
}
|
|
}
|
|
|
|
if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) {
|
|
// TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO.
|
|
return wuffs_base__make_status(
|
|
wuffs_base__error__unsupported_pixel_swizzler_option);
|
|
}
|
|
|
|
switch (dst->pixcfg.private_impl.pixfmt.repr) {
|
|
case WUFFS_BASE__PIXEL_FORMAT__Y:
|
|
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
|
|
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGB:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
|
break;
|
|
|
|
default:
|
|
// TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO.
|
|
return wuffs_base__make_status(
|
|
wuffs_base__error__unsupported_pixel_swizzler_option);
|
|
}
|
|
|
|
if ((width <= 0u) || (height <= 0u)) {
|
|
return wuffs_base__make_status(NULL);
|
|
}
|
|
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_func conv3func = NULL;
|
|
|
|
if (is_rgb_or_cmyk) {
|
|
conv3func = &wuffs_base__pixel_swizzler__swizzle_rgb__convert_3_general;
|
|
} else {
|
|
switch (dst->pixcfg.private_impl.pixfmt.repr) {
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
|
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
|
if (wuffs_base__cpu_arch__have_x86_avx2()) {
|
|
conv3func =
|
|
&wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_bgrx_x86_avx2;
|
|
break;
|
|
}
|
|
#endif
|
|
conv3func = &wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_bgrx;
|
|
break;
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
|
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
|
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
|
if (wuffs_base__cpu_arch__have_x86_avx2()) {
|
|
conv3func =
|
|
&wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_rgbx_x86_avx2;
|
|
break;
|
|
}
|
|
#endif
|
|
conv3func = &wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_rgbx;
|
|
break;
|
|
default:
|
|
conv3func = &wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_general;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void (*func)(
|
|
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, //
|
|
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(*upfuncs)[4][4],
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_3_func conv3func) =
|
|
&wuffs_base__pixel_swizzler__swizzle_ycc__general__box_filter;
|
|
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_func upfuncs[4][4];
|
|
memcpy(&upfuncs, &wuffs_base__pixel_swizzler__swizzle_ycc__upsample_funcs,
|
|
sizeof upfuncs);
|
|
|
|
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))) {
|
|
func = &wuffs_base__pixel_swizzler__swizzle_ycc__general__triangle_filter;
|
|
|
|
upfuncs[0][1] =
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h1v2_triangle;
|
|
upfuncs[1][0] =
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2v1_triangle;
|
|
upfuncs[1][1] =
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2v2_triangle;
|
|
|
|
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
|
|
#if defined(__GNUC__) && !defined(__clang__)
|
|
// Don't use our AVX2 implementation for GCC (but do use it for clang). For
|
|
// some unknown reason, GCC performs noticably better on the non-SIMD
|
|
// version. Possibly because GCC's auto-vectorizer is smarter (just with
|
|
// SSE2, not AVX2) than our hand-written code, but that's just a guess.
|
|
//
|
|
// See commits 51bc60ef9298cb2efc1b29a9681191f66d49820d and
|
|
// cd769a0cdf1b5affee13f6089b995f3d39569cb4 for benchmark numbers.
|
|
//
|
|
// See also https://godbolt.org/z/MbhbPGEz4 for Debian Bullseye's clang 11
|
|
// versus gcc 10, where only gcc auto-vectorizes, although later clang
|
|
// versions will also auto-vectorize.
|
|
#else
|
|
if (wuffs_base__cpu_arch__have_x86_avx2()) {
|
|
upfuncs[1][1] =
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2;
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
if ((h3 != 0u) || (v3 != 0u)) {
|
|
wuffs_base__pixel_swizzler__swizzle_ycc__convert_4_func conv4func =
|
|
is_rgb_or_cmyk
|
|
? &wuffs_base__pixel_swizzler__swizzle_cmyk__convert_4_general
|
|
: &wuffs_base__pixel_swizzler__swizzle_ycck__convert_4_general;
|
|
wuffs_base__pixel_swizzler__swizzle_ycck__general__triangle_filter( //
|
|
dst, width, height, //
|
|
src0.ptr, src1.ptr, src2.ptr, src3.ptr, //
|
|
stride0, stride1, stride2, stride3, //
|
|
inv_h0, inv_h1, inv_h2, inv_h3, //
|
|
inv_v0, inv_v1, inv_v2, inv_v3, //
|
|
half_width_for_2to1, half_height_for_2to1, //
|
|
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, //
|
|
scratch_buffer_2k.ptr, &upfuncs, conv3func);
|
|
}
|
|
|
|
return wuffs_base__make_status(NULL);
|
|
}
|