mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
SPDX is an ISO standard for describing licenses in a computer readable format, which is useful when applying license compliance tools and the like to source code. In addition to ensuring that the Wuffs C distribution is properly annotated to the benefit of projects using Wuffs and SPDX-supporting tools, add it everywhere else where there's a license in this repo for consistency, too.
1351 lines
47 KiB
C
1351 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.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
// --------
|
|
|
|
#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);
|
|
}
|