// 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_PRIVATE_IMPL__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2,avx2")
static void  //
wuffs_private_impl__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_private_impl__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_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64)

// --------

static inline uint32_t  //
wuffs_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__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_private_impl__swizzle_ycc__upsample_funcs is indexed by inv_h and then
// inv_v.
static const wuffs_private_impl__swizzle_ycc__upsample_func
    wuffs_private_impl__swizzle_ycc__upsample_funcs[4][4] = {
        {
            wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h1vn_box,
        },
        {
            wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h2vn_box,
        },
        {
            wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h3vn_box,
        },
        {
            wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box,
            wuffs_private_impl__swizzle_ycc__upsample_inv_h4vn_box,
        },
};

static inline uint32_t  //
wuffs_private_impl__swizzle_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_private_impl__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_private_impl__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_private_impl__swizzle_ycc__upsample_func upfunc0,
    wuffs_private_impl__swizzle_ycc__upsample_func upfunc1,
    wuffs_private_impl__swizzle_ycc__upsample_func upfunc2,
    wuffs_private_impl__swizzle_ycc__upsample_func upfunc3,
    wuffs_private_impl__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_private_impl__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_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
    wuffs_private_impl__swizzle_ycc__convert_4_func conv4func) {
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
      (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
      (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
      (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc3 =
      (*upfuncs)[(inv_h3 - 1u) & 3u][(inv_v3 - 1u) & 3u];

  // First row.
  uint32_t h1v2_bias = 1u;
  wuffs_private_impl__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_private_impl__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_private_impl__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_private_impl__swizzle_ycc__upsample_func upfunc0,
    wuffs_private_impl__swizzle_ycc__upsample_func upfunc1,
    wuffs_private_impl__swizzle_ycc__upsample_func upfunc2,
    wuffs_private_impl__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_private_impl__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_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
    wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
      (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
      (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc2 =
      (*upfuncs)[(inv_h2 - 1u) & 3u][(inv_v2 - 1u) & 3u];

  // First row.
  uint32_t h1v2_bias = 1u;
  wuffs_private_impl__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_private_impl__swizzle_ycc__general__triangle_filter_edge_row(
        dst, width, height - 1u,       //
        src_ptr0, src_ptr1, src_ptr2,  //
        stride0, stride1, stride2,     //
        inv_h0, inv_h1, inv_h2,        //
        inv_v0, inv_v1, inv_v2,        //
        half_width_for_2to1,           //
        h1v2_bias,                     //
        scratch_buffer_2k_ptr,         //
        upfunc0, upfunc1, upfunc2, conv3func);
  }
}

static void  //
wuffs_private_impl__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_private_impl__swizzle_ycc__upsample_func (*upfuncs)[4][4],
    wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) {
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc0 =
      (*upfuncs)[(inv_h0 - 1u) & 3u][(inv_v0 - 1u) & 3u];
  wuffs_private_impl__swizzle_ycc__upsample_func upfunc1 =
      (*upfuncs)[(inv_h1 - 1u) & 3u][(inv_v1 - 1u) & 3u];
  wuffs_private_impl__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_private_impl__swizzle_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_private_impl__swizzle_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_private_impl__u32__max_of_4(h0, h1, h2, h3);
  uint32_t max_incl_v = wuffs_private_impl__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_private_impl__u32__min_of_5(  //
      width,                                  //
      width0 * inv_h0,                        //
      width1 * inv_h1,                        //
      width2 * inv_h2,                        //
      wuffs_base__pixel_config__width(&dst->pixcfg));
  height = wuffs_private_impl__u32__min_of_5(  //
      height,                                  //
      height0 * inv_v0,                        //
      height1 * inv_v1,                        //
      height2 * inv_v2,                        //
      wuffs_base__pixel_config__height(&dst->pixcfg));

  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_private_impl__swizzle_flattened_length(
                      width, height, stride0, inv_h0, inv_v0)) ||
      (src1.len < wuffs_private_impl__swizzle_flattened_length(
                      width, height, stride1, inv_h1, inv_v1)) ||
      (src2.len < wuffs_private_impl__swizzle_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_private_impl__swizzle_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);
  }

  // ----

#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
  switch (dst->pixcfg.private_impl.pixfmt.repr) {
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565)
    case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR)
    case WUFFS_BASE__PIXEL_FORMAT__BGR:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL)
    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_NONPREMUL_4X16LE)
    case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGRA_PREMUL)
    case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGB)
    case WUFFS_BASE__PIXEL_FORMAT__RGB:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_NONPREMUL)
    case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
      break;
#endif
#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_RGBA_PREMUL)
    case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
      break;
#endif
    default:
      return wuffs_base__make_status(
          wuffs_base__error__disabled_by_wuffs_config_dst_pixel_format_enable_allowlist);
  }
#else   // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)
  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__YA_NONPREMUL:
    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);
  }
#endif  // defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST)

  // ----

  if ((width <= 0u) || (height <= 0u)) {
    return wuffs_base__make_status(NULL);
  }

  wuffs_private_impl__swizzle_ycc__convert_3_func conv3func = NULL;

  if (is_rgb_or_cmyk) {
    conv3func = &wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
        if (wuffs_base__cpu_arch__have_x86_avx2()) {
          conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_bgrx_x86_avx2;
          break;
        }
#endif
        conv3func = &wuffs_private_impl__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_PRIVATE_IMPL__CPU_ARCH__X86_64)
        if (wuffs_base__cpu_arch__have_x86_avx2()) {
          conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx_x86_avx2;
          break;
        }
#endif
        conv3func = &wuffs_private_impl__swizzle_ycc__convert_3_rgbx;
        break;
      default:
        conv3func = &wuffs_private_impl__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_private_impl__swizzle_ycc__upsample_func(*upfuncs)[4][4],
               wuffs_private_impl__swizzle_ycc__convert_3_func conv3func) =
      &wuffs_private_impl__swizzle_ycc__general__box_filter;

  wuffs_private_impl__swizzle_ycc__upsample_func upfuncs[4][4];
  memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
         sizeof upfuncs);

  if (triangle_filter_for_2to1 &&
      (wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
       wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
       wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2))) {
    func = &wuffs_private_impl__swizzle_ycc__general__triangle_filter;

    upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
    upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
    upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle;

#if defined(WUFFS_PRIVATE_IMPL__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_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2;
    }
#endif
#endif
  }

  if ((h3 != 0u) || (v3 != 0u)) {
    wuffs_private_impl__swizzle_ycc__convert_4_func conv4func =
        is_rgb_or_cmyk ? &wuffs_private_impl__swizzle_cmyk__convert_4_general
                       : &wuffs_private_impl__swizzle_ycck__convert_4_general;
    wuffs_private_impl__swizzle_ycck__general__triangle_filter(  //
        dst, width, height,                                      //
        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);
}