wuffs gen -version=0.3.0-beta.1

This commit is contained in:
Nigel Tao committed 2021-04-05 22:44:12 +10:00
1 parent c86ac5baef
commit 235c9301c3
1 file changed
+2239 -193
+2239 -193
View File
@@ -10,10 +10,15 @@
// Wuffs' C code is generated automatically, not hand-written. These warnings'
// costs outweigh the benefits.
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunused-function"
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#pragma GCC diagnostic ignored "-Wunreachable-code"
#pragma GCC diagnostic ignored "-Wunused-function"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
#endif
// Copyright 2017 The Wuffs Authors.
@@ -65,15 +70,15 @@ extern "C" {
// each major.minor branch, the commit count should increase monotonically.
//
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
// 8d909717823535088cacaa2cb43043449fc028c7 committed on 2021-03-18.
// c86ac5baef05b2e373b818eca0cf2c9c38785197 committed on 2021-04-03.
#define WUFFS_VERSION 0x000030000
#define WUFFS_VERSION_MAJOR 0
#define WUFFS_VERSION_MINOR 3
#define WUFFS_VERSION_PATCH 0
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.21"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 2990
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20210318
#define WUFFS_VERSION_STRING "0.3.0-alpha.21+2990.20210318"
#define WUFFS_VERSION_PRE_RELEASE_LABEL "beta.1"
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3024
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20210403
#define WUFFS_VERSION_STRING "0.3.0-beta.1+3024.20210403"
// ---------------- Configuration
@@ -217,18 +222,12 @@ wuffs_base__cpu_arch__have_x86_sse42() {
// Wuffs assumes that:
// - converting a uint32_t to a size_t will never overflow.
// - converting a size_t to a uint64_t will never overflow.
#ifdef __WORDSIZE
#if defined(__WORDSIZE)
#if (__WORDSIZE != 32) && (__WORDSIZE != 64)
#error "Wuffs requires a word size of either 32 or 64 bits"
#endif
#endif
#if defined(__clang__)
#define WUFFS_BASE__POTENTIALLY_UNUSED_FIELD __attribute__((unused))
#else
#define WUFFS_BASE__POTENTIALLY_UNUSED_FIELD
#endif
// Clang also defines "__GNUC__".
#if defined(__GNUC__)
#define WUFFS_BASE__POTENTIALLY_UNUSED __attribute__((unused))
@@ -1202,7 +1201,7 @@ wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {
// WUFFS_BASE__TABLE is a 2-dimensional buffer.
//
// width height, and stride measure a number of elements, not necessarily a
// width, height and stride measure a number of elements, not necessarily a
// size in bytes.
//
// A value with all fields NULL or zero is a valid, empty table.
@@ -1288,6 +1287,58 @@ wuffs_base__empty_slice_u64() {
return ret;
}
static inline wuffs_base__table_u8 //
wuffs_base__make_table_u8(uint8_t* ptr,
size_t width,
size_t height,
size_t stride) {
wuffs_base__table_u8 ret;
ret.ptr = ptr;
ret.width = width;
ret.height = height;
ret.stride = stride;
return ret;
}
static inline wuffs_base__table_u16 //
wuffs_base__make_table_u16(uint16_t* ptr,
size_t width,
size_t height,
size_t stride) {
wuffs_base__table_u16 ret;
ret.ptr = ptr;
ret.width = width;
ret.height = height;
ret.stride = stride;
return ret;
}
static inline wuffs_base__table_u32 //
wuffs_base__make_table_u32(uint32_t* ptr,
size_t width,
size_t height,
size_t stride) {
wuffs_base__table_u32 ret;
ret.ptr = ptr;
ret.width = width;
ret.height = height;
ret.stride = stride;
return ret;
}
static inline wuffs_base__table_u64 //
wuffs_base__make_table_u64(uint64_t* ptr,
size_t width,
size_t height,
size_t stride) {
wuffs_base__table_u64 ret;
ret.ptr = ptr;
ret.width = width;
ret.height = height;
ret.stride = stride;
return ret;
}
static inline wuffs_base__table_u8 //
wuffs_base__empty_table_u8() {
wuffs_base__table_u8 ret;
@@ -1369,6 +1420,45 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
return wuffs_base__make_slice_u8(NULL, 0);
}
// wuffs_base__table__flattened_length returns the number of elements covered
// by the 1-dimensional span that backs a 2-dimensional table. This counts the
// elements inside the table and, when width != stride, the elements outside
// the table but between its rows.
//
// For example, consider a width 10, height 4, stride 10 table. Mark its first
// and last (inclusive) elements with 'a' and 'z'. This function returns 40.
//
// a123456789
// 0123456789
// 0123456789
// 012345678z
//
// Now consider the sub-table of that from (2, 1) inclusive to (8, 4) exclusive.
//
// a123456789
// 01iiiiiioo
// ooiiiiiioo
// ooiiiiii8z
//
// This function (called with width 6, height 3, stride 10) returns 26: 18 'i'
// inside elements plus 8 'o' outside elements. Note that 26 is less than a
// naive (height * stride = 30) computation. Indeed, advancing 29 elements from
// the first 'i' would venture past 'z', out of bounds of the original table.
//
// It does not check for overflow, but if the arguments come from a table that
// exists in memory and each element occupies a positive number of bytes then
// the result should be bounded by the amount of allocatable memory (which
// shouldn't overflow SIZE_MAX).
static inline size_t //
wuffs_base__table__flattened_length(size_t width,
size_t height,
size_t stride) {
if (height == 0) {
return 0;
}
return ((height - 1) * stride) + width;
}
// ---------------- Magic Numbers
// wuffs_base__magic_number_guess_fourcc guesses the file format of some data,
@@ -3404,6 +3494,9 @@ typedef uint32_t wuffs_base__pixel_alpha_transparency;
#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0
#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3
// A palette is 256 entries × 4 bytes per entry (e.g. BGRA).
#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH 1024
// wuffs_base__pixel_format encodes the format of the bytes that constitute an
// image frame's pixel data.
//
@@ -3813,10 +3906,11 @@ wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) {
n *= bytes_per_pixel;
if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) {
if (n > (UINT64_MAX - 1024)) {
if (n >
(UINT64_MAX - WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {
return 0;
}
n += 1024;
n += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
}
return n;
@@ -4269,12 +4363,16 @@ typedef struct wuffs_base__pixel_buffer__struct {
} private_impl;
#ifdef __cplusplus
inline wuffs_base__status set_interleaved(
const wuffs_base__pixel_config* pixcfg,
wuffs_base__table_u8 primary_memory,
wuffs_base__slice_u8 palette_memory);
inline wuffs_base__status set_from_slice(
const wuffs_base__pixel_config* pixcfg,
wuffs_base__slice_u8 pixbuf_memory);
inline wuffs_base__status set_from_table(
const wuffs_base__pixel_config* pixcfg,
wuffs_base__table_u8 pixbuf_memory);
wuffs_base__table_u8 primary_memory);
inline wuffs_base__slice_u8 palette();
inline wuffs_base__slice_u8 palette_or_else(wuffs_base__slice_u8 fallback);
inline wuffs_base__pixel_format pixel_format() const;
@@ -4303,6 +4401,55 @@ wuffs_base__null_pixel_buffer() {
return ret;
}
static inline wuffs_base__status //
wuffs_base__pixel_buffer__set_interleaved(
wuffs_base__pixel_buffer* pb,
const wuffs_base__pixel_config* pixcfg,
wuffs_base__table_u8 primary_memory,
wuffs_base__slice_u8 palette_memory) {
if (!pb) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
memset(pb, 0, sizeof(*pb));
if (!pixcfg ||
wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) &&
(palette_memory.len <
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH)) {
return wuffs_base__make_status(
wuffs_base__error__bad_argument_length_too_short);
}
uint32_t bits_per_pixel =
wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);
if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {
// TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
uint64_t bytes_per_pixel = bits_per_pixel / 8;
uint64_t width_in_bytes =
((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;
if ((width_in_bytes > primary_memory.width) ||
(pixcfg->private_impl.height > primary_memory.height)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
pb->pixcfg = *pixcfg;
pb->private_impl.planes[0] = primary_memory;
if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {
wuffs_base__table_u8* tab =
&pb->private_impl
.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
tab->ptr = palette_memory.ptr;
tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
tab->height = 1;
tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
}
return wuffs_base__make_status(NULL);
}
static inline wuffs_base__status //
wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb,
const wuffs_base__pixel_config* pixcfg,
@@ -4329,11 +4476,12 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb,
uint8_t* ptr = pixbuf_memory.ptr;
uint64_t len = pixbuf_memory.len;
if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {
// Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from
// the start of pixbuf_memory. We split from the start, not the end, so
// that the both chunks' pointers have the same alignment as the original
// Split a WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH byte
// chunk (1024 bytes = 256 palette entries × 4 bytes per entry) from the
// start of pixbuf_memory. We split from the start, not the end, so that
// the both chunks' pointers have the same alignment as the original
// pointer, up to an alignment of 1024.
if (len < 1024) {
if (len < WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return wuffs_base__make_status(
wuffs_base__error__bad_argument_length_too_short);
}
@@ -4341,11 +4489,11 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb,
&pb->private_impl
.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
tab->ptr = ptr;
tab->width = 1024;
tab->width = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
tab->height = 1;
tab->stride = 1024;
ptr += 1024;
len -= 1024;
tab->stride = WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
ptr += WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
len -= WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH;
}
uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *
@@ -4371,15 +4519,18 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* pb,
return wuffs_base__make_status(NULL);
}
// Deprecated: does not handle indexed pixel configurations. Use
// wuffs_base__pixel_buffer__set_interleaved instead.
static inline wuffs_base__status //
wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* pb,
const wuffs_base__pixel_config* pixcfg,
wuffs_base__table_u8 pixbuf_memory) {
wuffs_base__table_u8 primary_memory) {
if (!pb) {
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
}
memset(pb, 0, sizeof(*pb));
if (!pixcfg ||
wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt) ||
wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
@@ -4393,18 +4544,19 @@ wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* pb,
uint64_t width_in_bytes =
((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;
if ((width_in_bytes > pixbuf_memory.width) ||
(pixcfg->private_impl.height > pixbuf_memory.height)) {
if ((width_in_bytes > primary_memory.width) ||
(pixcfg->private_impl.height > primary_memory.height)) {
return wuffs_base__make_status(wuffs_base__error__bad_argument);
}
pb->pixcfg = *pixcfg;
pb->private_impl.planes[0] = pixbuf_memory;
pb->private_impl.planes[0] = primary_memory;
return wuffs_base__make_status(NULL);
}
// wuffs_base__pixel_buffer__palette returns the palette color data. If
// non-empty, it will have length 1024.
// non-empty, it will have length
// WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH.
static inline wuffs_base__slice_u8 //
wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) {
if (pb &&
@@ -4412,8 +4564,11 @@ wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* pb) {
wuffs_base__table_u8* tab =
&pb->private_impl
.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
if ((tab->width == 1024) && (tab->height == 1)) {
return wuffs_base__make_slice_u8(tab->ptr, 1024);
if ((tab->width ==
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&
(tab->height == 1)) {
return wuffs_base__make_slice_u8(
tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);
}
}
return wuffs_base__make_slice_u8(NULL, 0);
@@ -4427,8 +4582,11 @@ wuffs_base__pixel_buffer__palette_or_else(wuffs_base__pixel_buffer* pb,
wuffs_base__table_u8* tab =
&pb->private_impl
.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
if ((tab->width == 1024) && (tab->height == 1)) {
return wuffs_base__make_slice_u8(tab->ptr, 1024);
if ((tab->width ==
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) &&
(tab->height == 1)) {
return wuffs_base__make_slice_u8(
tab->ptr, WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH);
}
}
return fallback;
@@ -4476,6 +4634,15 @@ wuffs_base__pixel_buffer__set_color_u32_fill_rect(
#ifdef __cplusplus
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_interleaved(
const wuffs_base__pixel_config* pixcfg_arg,
wuffs_base__table_u8 primary_memory,
wuffs_base__slice_u8 palette_memory) {
return wuffs_base__pixel_buffer__set_interleaved(
this, pixcfg_arg, primary_memory, palette_memory);
}
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_from_slice(
const wuffs_base__pixel_config* pixcfg_arg,
@@ -4487,9 +4654,9 @@ wuffs_base__pixel_buffer::set_from_slice(
inline wuffs_base__status //
wuffs_base__pixel_buffer::set_from_table(
const wuffs_base__pixel_config* pixcfg_arg,
wuffs_base__table_u8 pixbuf_memory) {
wuffs_base__table_u8 primary_memory) {
return wuffs_base__pixel_buffer__set_from_table(this, pixcfg_arg,
pixbuf_memory);
primary_memory);
}
inline wuffs_base__slice_u8 //
@@ -9369,6 +9536,8 @@ namespace sync_io {
class Input {
public:
virtual ~Input();
virtual IOBuffer* BringsItsOwnIOBuffer();
virtual std::string CopyIn(IOBuffer* dst) = 0;
};
@@ -9432,6 +9601,8 @@ struct DecodeCborResult {
class DecodeCborCallbacks {
public:
virtual ~DecodeCborCallbacks();
// AppendXxx are called for leaf nodes: literals, numbers, strings, etc.
virtual std::string AppendNull() = 0;
@@ -9492,13 +9663,11 @@ namespace wuffs_aux {
struct DecodeImageResult {
DecodeImageResult(MemOwner&& pixbuf_mem_owner0,
wuffs_base__slice_u8 pixbuf_mem_slice0,
wuffs_base__pixel_buffer pixbuf0,
std::string&& error_message0);
DecodeImageResult(std::string&& error_message0);
MemOwner pixbuf_mem_owner;
wuffs_base__slice_u8 pixbuf_mem_slice;
wuffs_base__pixel_buffer pixbuf;
std::string error_message;
};
@@ -9515,18 +9684,32 @@ struct DecodeImageResult {
// one fails - but the final callback (Done) is always invoked.
class DecodeImageCallbacks {
public:
// AllocResult holds a memory allocation (the result of malloc or new, a
// statically allocated pointer, etc), or an error message. The memory is
// AllocPixbufResult holds a memory allocation (the result of malloc or new,
// a statically allocated pointer, etc), or an error message. The memory is
// de-allocated when mem_owner goes out of scope and is destroyed.
struct AllocResult {
AllocResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 mem_slice0);
AllocResult(std::string&& error_message0);
struct AllocPixbufResult {
AllocPixbufResult(MemOwner&& mem_owner0, wuffs_base__pixel_buffer pixbuf0);
AllocPixbufResult(std::string&& error_message0);
MemOwner mem_owner;
wuffs_base__slice_u8 mem_slice;
wuffs_base__pixel_buffer pixbuf;
std::string error_message;
};
// AllocWorkbufResult holds a memory allocation (the result of malloc or new,
// a statically allocated pointer, etc), or an error message. The memory is
// de-allocated when mem_owner goes out of scope and is destroyed.
struct AllocWorkbufResult {
AllocWorkbufResult(MemOwner&& mem_owner0, wuffs_base__slice_u8 workbuf0);
AllocWorkbufResult(std::string&& error_message0);
MemOwner mem_owner;
wuffs_base__slice_u8 workbuf;
std::string error_message;
};
virtual ~DecodeImageCallbacks();
// SelectDecoder returns the image decoder for the input data's file format.
// Returning a nullptr means failure (DecodeImage_UnsupportedImageFormat).
//
@@ -9557,7 +9740,10 @@ class DecodeImageCallbacks {
// - WUFFS_BASE__PIXEL_FORMAT__BGR_565
// - WUFFS_BASE__PIXEL_FORMAT__BGR
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE
// - WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL
// - WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL
// - WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL
// or return image_config.pixcfg.pixel_format(). The latter means to use the
// image file's natural pixel format. For example, GIF images' natural pixel
// format is an indexed one.
@@ -9565,8 +9751,8 @@ class DecodeImageCallbacks {
// Returning otherwise means failure (DecodeImage_UnsupportedPixelFormat).
//
// The default SelectPixfmt implementation returns
// wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL)
// which is 4 bytes per pixel (8 bits per channel × 4 channels).
// wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) which
// is 4 bytes per pixel (8 bits per channel × 4 channels).
virtual wuffs_base__pixel_format //
SelectPixfmt(const wuffs_base__image_config& image_config);
@@ -9579,7 +9765,7 @@ class DecodeImageCallbacks {
// The default AllocPixbuf implementation allocates either uninitialized or
// zeroed memory. Zeroed memory typically corresponds to filling with opaque
// black or transparent black, depending on the pixel format.
virtual AllocResult //
virtual AllocPixbufResult //
AllocPixbuf(const wuffs_base__image_config& image_config,
bool allow_uninitialized_memory);
@@ -9589,7 +9775,7 @@ class DecodeImageCallbacks {
//
// The default AllocWorkbuf implementation allocates len_range.max_incl bytes
// of either uninitialized or zeroed memory.
virtual AllocResult //
virtual AllocWorkbufResult //
AllocWorkbuf(wuffs_base__range_ii_u64 len_range,
bool allow_uninitialized_memory);
@@ -9687,6 +9873,8 @@ struct DecodeJsonResult {
class DecodeJsonCallbacks {
public:
virtual ~DecodeJsonCallbacks();
// AppendXxx are called for leaf nodes: literals, numbers and strings. For
// strings, the Callbacks implementation is responsible for tracking map keys
// versus other values.
@@ -9753,7 +9941,7 @@ DecodeJson(DecodeJsonCallbacks& callbacks,
#endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
// WUFFS C HEADER ENDS HERE.
// ‼ WUFFS C HEADER ENDS HERE.
#ifdef WUFFS_IMPLEMENTATION
#ifdef __cplusplus
@@ -10207,9 +10395,6 @@ wuffs_base__io_writer__limited_copy_u32_from_history(uint8_t** ptr_iop_w,
// expression '3'.
//
// See also wuffs_base__io_writer__limited_copy_u32_from_history_fast below.
//
// Alternatively or additionally, have a sloppy_limited_copy_u32_from_history
// method that copies 8 bytes at a time, which can more than length bytes?
for (; n >= 3; n -= 3) {
*p++ = *q++;
*p++ = *q++;
@@ -14760,12 +14945,29 @@ match:
static inline uint32_t //
wuffs_base__swap_u32_argb_abgr(uint32_t u) {
uint32_t o = u & 0xFF00FF00;
uint32_t r = u & 0x00FF0000;
uint32_t b = u & 0x000000FF;
uint32_t o = u & 0xFF00FF00ul;
uint32_t r = u & 0x00FF0000ul;
uint32_t b = u & 0x000000FFul;
return o | (r >> 16) | (b << 16);
}
static inline uint64_t //
wuffs_base__swap_u64_argb_abgr(uint64_t u) {
uint64_t o = u & 0xFFFF0000FFFF0000ull;
uint64_t r = u & 0x0000FFFF00000000ull;
uint64_t b = u & 0x000000000000FFFFull;
return o | (r >> 32) | (b << 32);
}
static inline uint32_t //
wuffs_base__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) {
uint32_t a = ((uint32_t)(0xFF & (c >> 56)));
uint32_t r = ((uint32_t)(0xFF & (c >> 40)));
uint32_t g = ((uint32_t)(0xFF & (c >> 24)));
uint32_t b = ((uint32_t)(0xFF & (c >> 8)));
return (a << 24) | (b << 16) | (g << 8) | (r << 0);
}
// --------
WUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //
@@ -15168,8 +15370,8 @@ wuffs_base__pixel_palette__closest_element(
wuffs_base__pixel_format palette_format,
wuffs_base__color_u32_argb_premul c) {
size_t n = palette_slice.len / 4;
if (n > 256) {
n = 256;
if (n > (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
n = (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4);
}
size_t best_index = 0;
uint64_t best_score = 0xFFFFFFFFFFFFFFFF;
@@ -15350,6 +15552,44 @@ wuffs_base__composite_nonpremul_premul_u32_axxx(uint32_t dst_nonpremul,
return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);
}
static inline uint64_t //
wuffs_base__composite_nonpremul_premul_u64_axxx(uint64_t dst_nonpremul,
uint64_t src_premul) {
// Extract components.
uint64_t sa = 0xFFFF & (src_premul >> 48);
uint64_t sr = 0xFFFF & (src_premul >> 32);
uint64_t sg = 0xFFFF & (src_premul >> 16);
uint64_t sb = 0xFFFF & (src_premul >> 0);
uint64_t da = 0xFFFF & (dst_nonpremul >> 48);
uint64_t dr = 0xFFFF & (dst_nonpremul >> 32);
uint64_t dg = 0xFFFF & (dst_nonpremul >> 16);
uint64_t db = 0xFFFF & (dst_nonpremul >> 0);
// Convert dst from nonpremul to premul.
dr = (dr * da) / 0xFFFF;
dg = (dg * da) / 0xFFFF;
db = (db * da) / 0xFFFF;
// Calculate the inverse of the src-alpha: how much of the dst to keep.
uint64_t ia = 0xFFFF - sa;
// Composite src (premul) over dst (premul).
da = sa + ((da * ia) / 0xFFFF);
dr = sr + ((dr * ia) / 0xFFFF);
dg = sg + ((dg * ia) / 0xFFFF);
db = sb + ((db * ia) / 0xFFFF);
// Convert dst from premul to nonpremul.
if (da != 0) {
dr = (dr * 0xFFFF) / da;
dg = (dg * 0xFFFF) / da;
db = (db * 0xFFFF) / da;
}
// Combine components.
return (db << 0) | (dg << 16) | (dr << 32) | (da << 48);
}
static inline uint32_t //
wuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,
uint32_t src_nonpremul) {
@@ -15486,20 +15726,21 @@ wuffs_base__pixel_swizzler__swap_rgb_bgr(uint8_t* dst_ptr,
size_t n = len;
while (n--) {
uint8_t b0 = s[0];
uint8_t b1 = s[1];
uint8_t b2 = s[2];
d[0] = b2;
d[1] = b1;
d[2] = b0;
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
d[0] = s2;
d[1] = s1;
d[2] = s0;
s += 3;
d += 3;
}
return len;
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("sse4.2")
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
size_t dst_len,
@@ -15529,20 +15770,21 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42(uint8_t* dst_ptr,
}
while (n--) {
uint8_t b0 = s[0];
uint8_t b1 = s[1];
uint8_t b2 = s[2];
uint8_t b3 = s[3];
d[0] = b2;
d[1] = b1;
d[2] = b0;
d[3] = b3;
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
uint8_t s3 = s[3];
d[0] = s2;
d[1] = s1;
d[2] = s0;
d[3] = s3;
s += 4;
d += 4;
}
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
wuffs_base__pixel_swizzler__swap_rgbx_bgrx(uint8_t* dst_ptr,
@@ -15557,14 +15799,14 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx(uint8_t* dst_ptr,
size_t n = len;
while (n--) {
uint8_t b0 = s[0];
uint8_t b1 = s[1];
uint8_t b2 = s[2];
uint8_t b3 = s[3];
d[0] = b2;
d[1] = b1;
d[2] = b0;
d[3] = b3;
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
uint8_t s3 = s[3];
d[0] = s2;
d[1] = s1;
d[2] = s0;
d[3] = s3;
s += 4;
d += 4;
}
@@ -15573,34 +15815,6 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx(uint8_t* dst_ptr,
// --------
static uint64_t //
wuffs_base__pixel_swizzler__squash_tight_4x8_4x16le(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len8 = src_len / 8;
size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__color_u64__as__color_u32(
wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
s += 1 * 8;
d += 1 * 4;
n -= 1;
}
return len;
}
// --------
static uint64_t //
wuffs_base__pixel_swizzler__copy_1_1(uint8_t* dst_ptr,
size_t dst_len,
@@ -15615,6 +15829,22 @@ wuffs_base__pixel_swizzler__copy_1_1(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__copy_2_2(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len2 = src_len / 2;
size_t len = (dst_len2 < src_len2) ? dst_len2 : src_len2;
if (len > 0) {
memmove(dst_ptr, src_ptr, len * 2);
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__copy_3_3(uint8_t* dst_ptr,
size_t dst_len,
@@ -15647,6 +15877,22 @@ wuffs_base__pixel_swizzler__copy_4_4(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__copy_8_8(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len8 = src_len / 8;
size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
if (len > 0) {
memmove(dst_ptr, src_ptr, len * 8);
}
return len;
}
// --------
static uint64_t //
@@ -15887,6 +16133,91 @@ wuffs_base__pixel_swizzler__bgr_565__bgra_nonpremul_4x16le__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len4 = src_len / 4;
size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
wuffs_base__poke_u16le__no_bounds_check(
d + (0 * 2), wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
s += 1 * 4;
d += 1 * 2;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len4 = src_len / 4;
size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
// Extract 16-bit color components.
uint32_t sa = 0x101 * ((uint32_t)s[3]);
uint32_t sr = 0x101 * ((uint32_t)s[2]);
uint32_t sg = 0x101 * ((uint32_t)s[1]);
uint32_t sb = 0x101 * ((uint32_t)s[0]);
// Convert from 565 color to 16-bit color.
uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
uint32_t dr = (0x8421 * old_r5) >> 4;
uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
uint32_t dg = (0x1041 * old_g6) >> 2;
uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
uint32_t db = (0x8421 * old_b5) >> 4;
// Calculate the inverse of the src-alpha: how much of the dst to keep.
uint32_t ia = 0xFFFF - sa;
// Composite src (premul) over dst (premul).
dr = sr + ((dr * ia) / 0xFFFF);
dg = sg + ((dg * ia) / 0xFFFF);
db = sb + ((db * ia) / 0xFFFF);
// Convert from 16-bit color to 565 color and combine the components.
uint32_t new_r5 = 0x1F & (dr >> 11);
uint32_t new_g6 = 0x3F & (dg >> 10);
uint32_t new_b5 = 0x1F & (db >> 11);
uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
s += 1 * 4;
d += 1 * 2;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr_565__rgb(uint8_t* dst_ptr,
size_t dst_len,
@@ -16007,6 +16338,93 @@ wuffs_base__pixel_swizzler__bgr_565__rgba_nonpremul__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len4 = src_len / 4;
size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
wuffs_base__poke_u16le__no_bounds_check(
d + (0 * 2),
wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));
s += 1 * 4;
d += 1 * 2;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len2 = dst_len / 2;
size_t src_len4 = src_len / 4;
size_t len = (dst_len2 < src_len4) ? dst_len2 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
// Extract 16-bit color components.
uint32_t sa = 0x101 * ((uint32_t)s[3]);
uint32_t sb = 0x101 * ((uint32_t)s[2]);
uint32_t sg = 0x101 * ((uint32_t)s[1]);
uint32_t sr = 0x101 * ((uint32_t)s[0]);
// Convert from 565 color to 16-bit color.
uint32_t old_rgb_565 = wuffs_base__peek_u16le__no_bounds_check(d + (0 * 2));
uint32_t old_r5 = 0x1F & (old_rgb_565 >> 11);
uint32_t dr = (0x8421 * old_r5) >> 4;
uint32_t old_g6 = 0x3F & (old_rgb_565 >> 5);
uint32_t dg = (0x1041 * old_g6) >> 2;
uint32_t old_b5 = 0x1F & (old_rgb_565 >> 0);
uint32_t db = (0x8421 * old_b5) >> 4;
// Calculate the inverse of the src-alpha: how much of the dst to keep.
uint32_t ia = 0xFFFF - sa;
// Composite src (premul) over dst (premul).
dr = sr + ((dr * ia) / 0xFFFF);
dg = sg + ((dg * ia) / 0xFFFF);
db = sb + ((db * ia) / 0xFFFF);
// Convert from 16-bit color to 565 color and combine the components.
uint32_t new_r5 = 0x1F & (dr >> 11);
uint32_t new_g6 = 0x3F & (dg >> 10);
uint32_t new_b5 = 0x1F & (db >> 11);
uint32_t new_rgb_565 = (new_r5 << 11) | (new_g6 << 5) | (new_b5 << 0);
wuffs_base__poke_u16le__no_bounds_check(d + (0 * 2), (uint16_t)new_rgb_565);
s += 1 * 4;
d += 1 * 2;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr_565__y(uint8_t* dst_ptr,
size_t dst_len,
@@ -16073,7 +16491,8 @@ wuffs_base__pixel_swizzler__bgr_565__index__src(uint8_t* dst_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len2 = dst_len / 2;
@@ -16124,7 +16543,8 @@ wuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len2 = dst_len / 2;
@@ -16161,7 +16581,8 @@ wuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len2 = dst_len / 2;
@@ -16189,6 +16610,35 @@ wuffs_base__pixel_swizzler__bgr_565__index_binary_alpha__src_over(
// --------
static uint64_t //
wuffs_base__pixel_swizzler__bgr__bgr_565(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len3 = dst_len / 3;
size_t src_len2 = src_len / 2;
size_t len = (dst_len3 < src_len2) ? dst_len3 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)));
wuffs_base__poke_u24le__no_bounds_check(d + (0 * 3), s0);
s += 1 * 2;
d += 1 * 3;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr__bgra_nonpremul__src(uint8_t* dst_ptr,
size_t dst_len,
@@ -16346,6 +16796,81 @@ wuffs_base__pixel_swizzler__bgr__bgra_nonpremul_4x16le__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr__bgra_premul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len3 = dst_len / 3;
size_t src_len4 = src_len / 4;
size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
d[0] = s0;
d[1] = s1;
d[2] = s2;
s += 1 * 4;
d += 1 * 3;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len3 = dst_len / 3;
size_t src_len4 = src_len / 4;
size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
// Extract 16-bit color components.
uint32_t sa = 0x101 * ((uint32_t)s[3]);
uint32_t sr = 0x101 * ((uint32_t)s[2]);
uint32_t sg = 0x101 * ((uint32_t)s[1]);
uint32_t sb = 0x101 * ((uint32_t)s[0]);
uint32_t dr = 0x101 * ((uint32_t)d[2]);
uint32_t dg = 0x101 * ((uint32_t)d[1]);
uint32_t db = 0x101 * ((uint32_t)d[0]);
// Calculate the inverse of the src-alpha: how much of the dst to keep.
uint32_t ia = 0xFFFF - sa;
// Composite src (premul) over dst (premul).
dr = sr + ((dr * ia) / 0xFFFF);
dg = sg + ((dg * ia) / 0xFFFF);
db = sb + ((db * ia) / 0xFFFF);
// Convert from 16-bit color to 8-bit color.
d[0] = (uint8_t)(db >> 8);
d[1] = (uint8_t)(dg >> 8);
d[2] = (uint8_t)(dr >> 8);
s += 1 * 4;
d += 1 * 3;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src(uint8_t* dst_ptr,
size_t dst_len,
@@ -16424,6 +16949,81 @@ wuffs_base__pixel_swizzler__bgr__rgba_nonpremul__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr__rgba_premul__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len3 = dst_len / 3;
size_t src_len4 = src_len / 4;
size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
d[0] = s2;
d[1] = s1;
d[2] = s0;
s += 1 * 4;
d += 1 * 3;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len3 = dst_len / 3;
size_t src_len4 = src_len / 4;
size_t len = (dst_len3 < src_len4) ? dst_len3 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
// Extract 16-bit color components.
uint32_t sa = 0x101 * ((uint32_t)s[3]);
uint32_t sb = 0x101 * ((uint32_t)s[2]);
uint32_t sg = 0x101 * ((uint32_t)s[1]);
uint32_t sr = 0x101 * ((uint32_t)s[0]);
uint32_t dr = 0x101 * ((uint32_t)d[2]);
uint32_t dg = 0x101 * ((uint32_t)d[1]);
uint32_t db = 0x101 * ((uint32_t)d[0]);
// Calculate the inverse of the src-alpha: how much of the dst to keep.
uint32_t ia = 0xFFFF - sa;
// Composite src (premul) over dst (premul).
dr = sr + ((dr * ia) / 0xFFFF);
dg = sg + ((dg * ia) / 0xFFFF);
db = sb + ((db * ia) / 0xFFFF);
// Convert from 16-bit color to 8-bit color.
d[0] = (uint8_t)(db >> 8);
d[1] = (uint8_t)(dg >> 8);
d[2] = (uint8_t)(dr >> 8);
s += 1 * 4;
d += 1 * 3;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -16456,6 +17056,33 @@ wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len8 = src_len / 8;
size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__color_u64__as__color_u32(
wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
s += 1 * 8;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over(
uint8_t* dst_ptr,
@@ -16488,6 +17115,64 @@ wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4),
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0));
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__composite_nonpremul_premul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over(
uint8_t* dst_ptr,
@@ -16496,7 +17181,8 @@ wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len4 = dst_len / 4;
@@ -16554,6 +17240,381 @@ wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 = wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4),
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(s0));
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
uint32_t s0 = wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__composite_nonpremul_premul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
// --------
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
uint8_t s3 = s[3];
d[0] = s0;
d[1] = s0;
d[2] = s1;
d[3] = s1;
d[4] = s2;
d[5] = s2;
d[6] = s3;
d[7] = s3;
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
uint64_t s0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8),
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len8 = src_len / 8;
size_t len = (dst_len8 < src_len8) ? dst_len8 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8),
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
s += 1 * 8;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t s0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
uint64_t s0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8), wuffs_base__composite_nonpremul_premul_u64_axxx(d0, s0));
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len8 = dst_len / 8;
size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
uint64_t s0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
((size_t)s[0] * 4)));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8),
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
s += 1 * 1;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
uint8_t s3 = s[3];
d[0] = s2;
d[1] = s2;
d[2] = s1;
d[3] = s1;
d[4] = s0;
d[5] = s0;
d[6] = s3;
d[7] = s3;
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
uint64_t s0 =
wuffs_base__color_u32__as__color_u64(wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8),
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0));
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t s0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__color_u32_argb_premul__as__color_u32_argb_nonpremul(
wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))));
wuffs_base__poke_u64le__no_bounds_check(d + (0 * 8), s0);
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__peek_u64le__no_bounds_check(d + (0 * 8));
uint64_t s0 =
wuffs_base__color_u32__as__color_u64(wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8), wuffs_base__composite_nonpremul_premul_u64_axxx(d0, s0));
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -16683,6 +17744,37 @@ wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul_4x16le__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__composite_premul_premul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over(
uint8_t* dst_ptr,
@@ -16691,7 +17783,8 @@ wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len4 = dst_len / 4;
@@ -16781,6 +17874,104 @@ wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over(
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len8 = src_len / 8;
size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
uint64_t s0 = wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4),
wuffs_base__swap_u32_argb_abgr(
wuffs_base__color_u64_argb_nonpremul__as__color_u32_argb_premul(
s0)));
s += 1 * 8;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len8 = src_len / 8;
size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
uint64_t d0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
uint64_t s0 = wuffs_base__swap_u64_argb_abgr(
wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4),
wuffs_base__color_u64__as__color_u32(
wuffs_base__composite_premul_nonpremul_u64_axxx(d0, s0)));
s += 1 * 8;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t d0 = wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4));
uint32_t s0 = wuffs_base__swap_u32_argb_abgr(
wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__composite_premul_premul_u32_axxx(d0, s0));
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -16812,6 +18003,35 @@ wuffs_base__pixel_swizzler__bgrw__bgr(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__bgr_565(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len2 = src_len / 2;
size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))));
s += 1 * 2;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
size_t dst_len,
@@ -16841,8 +18061,9 @@ wuffs_base__pixel_swizzler__bgrw__bgrx(uint8_t* dst_ptr,
return len;
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("sse4.2")
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
size_t dst_len,
@@ -16895,6 +18116,7 @@ wuffs_base__pixel_swizzler__bgrw__rgb__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__rgb(uint8_t* dst_ptr,
@@ -16927,6 +18149,270 @@ wuffs_base__pixel_swizzler__bgrw__rgb(uint8_t* dst_ptr,
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgrw__rgbx(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len4 = src_len / 4;
size_t len = (dst_len4 < src_len4) ? dst_len4 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
uint8_t b0 = s[0];
uint8_t b1 = s[1];
uint8_t b2 = s[2];
d[0] = b2;
d[1] = b1;
d[2] = b0;
d[3] = 0xFF;
s += 1 * 4;
d += 1 * 4;
n -= 1;
}
return len;
}
// --------
static uint64_t //
wuffs_base__pixel_swizzler__bgrw_4x16le__bgr(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len3 = src_len / 3;
size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
d[0] = s0;
d[1] = s0;
d[2] = s1;
d[3] = s1;
d[4] = s2;
d[5] = s2;
d[6] = 0xFF;
d[7] = 0xFF;
s += 1 * 3;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len2 = src_len / 2;
size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8),
wuffs_base__color_u32__as__color_u64(
wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));
s += 1 * 2;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgrw_4x16le__bgrx(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len4 = src_len / 4;
size_t len = (dst_len8 < src_len4) ? dst_len8 : src_len4;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
d[0] = s0;
d[1] = s0;
d[2] = s1;
d[3] = s1;
d[4] = s2;
d[5] = s2;
d[6] = 0xFF;
d[7] = 0xFF;
s += 1 * 4;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__bgrw_4x16le__rgb(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len3 = src_len / 3;
size_t len = (dst_len8 < src_len3) ? dst_len8 : src_len3;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint8_t s0 = s[0];
uint8_t s1 = s[1];
uint8_t s2 = s[2];
d[0] = s2;
d[1] = s2;
d[2] = s1;
d[3] = s1;
d[4] = s0;
d[5] = s0;
d[6] = 0xFF;
d[7] = 0xFF;
s += 1 * 3;
d += 1 * 8;
n -= 1;
}
return len;
}
// --------
static uint64_t //
wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len8 = src_len / 8;
size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4), wuffs_base__color_u64__as__color_u32__swap_u32_argb_abgr(
wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))));
s += 1 * 8;
d += 1 * 4;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len8 = src_len / 8;
size_t len = (dst_len4 < src_len8) ? dst_len4 : src_len8;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t d0 = wuffs_base__color_u32__as__color_u64(
wuffs_base__peek_u32le__no_bounds_check(d + (0 * 4)));
uint64_t s0 = wuffs_base__swap_u64_argb_abgr(
wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8)));
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4),
wuffs_base__color_u64__as__color_u32(
wuffs_base__composite_nonpremul_nonpremul_u64_axxx(d0, s0)));
s += 1 * 8;
d += 1 * 4;
n -= 1;
}
return len;
}
// --------
static uint64_t //
wuffs_base__pixel_swizzler__rgbw__bgr_565(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len4 = dst_len / 4;
size_t src_len2 = src_len / 2;
size_t len = (dst_len4 < src_len2) ? dst_len4 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
// TODO: unroll.
while (n >= 1) {
wuffs_base__poke_u32le__no_bounds_check(
d + (0 * 4),
wuffs_base__swap_u32_argb_abgr(
wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2)))));
s += 1 * 2;
d += 1 * 4;
n -= 1;
}
return len;
}
// --------
static uint64_t //
@@ -16936,7 +18422,8 @@ wuffs_base__pixel_swizzler__xxx__index__src(uint8_t* dst_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len3 = dst_len / 3;
@@ -16994,7 +18481,8 @@ wuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len3 = dst_len / 3;
@@ -17029,7 +18517,8 @@ wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len3 = dst_len / 3;
@@ -17178,7 +18667,8 @@ wuffs_base__pixel_swizzler__xxxx__index__src(uint8_t* dst_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len4 = dst_len / 4;
@@ -17229,7 +18719,8 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len != 1024) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len4 = dst_len / 4;
@@ -17282,8 +18773,9 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(
return len;
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("sse4.2")
WUFFS_BASE__MAYBE_ATTRIBUTE_TARGET("pclmul,popcnt,sse4.2")
static uint64_t //
wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
size_t dst_len,
@@ -17330,6 +18822,7 @@ wuffs_base__pixel_swizzler__xxxx__y__sse42(uint8_t* dst_ptr,
return len;
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
static uint64_t //
wuffs_base__pixel_swizzler__xxxx__y(uint8_t* dst_ptr,
@@ -17384,6 +18877,126 @@ wuffs_base__pixel_swizzler__xxxx__y_16be(uint8_t* dst_ptr,
// --------
static uint64_t //
wuffs_base__pixel_swizzler__xxxxxxxx__index__src(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len8 = dst_len / 8;
size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8), wuffs_base__color_u32__as__color_u64(
wuffs_base__peek_u32le__no_bounds_check(
dst_palette_ptr + ((size_t)s[0] * 4))));
s += 1 * 1;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__xxxxxxxx__index_binary_alpha__src_over(
uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
if (dst_palette_len !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return 0;
}
size_t dst_len8 = dst_len / 8;
size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr +
((size_t)s[0] * 4));
if (s0) {
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8), wuffs_base__color_u32__as__color_u64(s0));
}
s += 1 * 1;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__xxxxxxxx__y(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t len = (dst_len8 < src_len) ? dst_len8 : src_len;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8), 0xFFFF000000000000 | (0x010101010101 * (uint64_t)s[0]));
s += 1 * 1;
d += 1 * 8;
n -= 1;
}
return len;
}
static uint64_t //
wuffs_base__pixel_swizzler__xxxxxxxx__y_16be(uint8_t* dst_ptr,
size_t dst_len,
uint8_t* dst_palette_ptr,
size_t dst_palette_len,
const uint8_t* src_ptr,
size_t src_len) {
size_t dst_len8 = dst_len / 8;
size_t src_len2 = src_len / 2;
size_t len = (dst_len8 < src_len2) ? dst_len8 : src_len2;
uint8_t* d = dst_ptr;
const uint8_t* s = src_ptr;
size_t n = len;
while (n >= 1) {
uint64_t s0 =
((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(s + (0 * 2))));
wuffs_base__poke_u64le__no_bounds_check(
d + (0 * 8), 0xFFFF000000000000 | (0x000100010001 * s0));
s += 1 * 2;
d += 1 * 8;
n -= 1;
}
return len;
}
// --------
static uint64_t //
wuffs_base__pixel_swizzler__y__y_16be(uint8_t* dst_ptr,
size_t dst_len,
@@ -17474,6 +19087,12 @@ wuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,
}
#endif
return wuffs_base__pixel_swizzler__xxxx__y;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:
return wuffs_base__pixel_swizzler__xxxxxxxx__y;
}
return NULL;
}
@@ -17505,6 +19124,12 @@ wuffs_base__pixel_swizzler__prepare__y_16be(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
return wuffs_base__pixel_swizzler__xxxx__y_16be;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL_4X16LE:
return wuffs_base__pixel_swizzler__xxxxxxxx__y_16be;
}
return NULL;
}
@@ -17519,7 +19144,7 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
@@ -17533,13 +19158,14 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(
case WUFFS_BASE__PIXEL_BLEND__SRC:
if (wuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(
dst_palette.ptr, dst_palette.len, src_palette.ptr,
src_palette.len, true) != 256) {
src_palette.len, true) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
return wuffs_base__pixel_swizzler__bgr_565__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
return wuffs_base__pixel_swizzler__bgr_565__index_bgra_nonpremul__src_over;
@@ -17551,13 +19177,14 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(
case WUFFS_BASE__PIXEL_BLEND__SRC:
if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) != 256) {
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
return wuffs_base__pixel_swizzler__xxx__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
return wuffs_base__pixel_swizzler__xxx__index_bgra_nonpremul__src_over;
@@ -17566,7 +19193,7 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
@@ -17577,18 +19204,32 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__xxxxxxxx__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__index_bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
if (wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) != 256) {
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
return wuffs_base__pixel_swizzler__xxxx__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
return wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over;
@@ -17596,8 +19237,45 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_nonpremul(
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
// TODO.
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__xxxx__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__index_bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
if (wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
return wuffs_base__pixel_swizzler__xxxx__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
return wuffs_base__pixel_swizzler__bgra_premul__index_bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
break;
@@ -17617,7 +19295,7 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
@@ -17629,7 +19307,8 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
if (wuffs_base__pixel_swizzler__squash_align4_bgr_565_8888(
dst_palette.ptr, dst_palette.len, src_palette.ptr,
src_palette.len, false) != 256) {
src_palette.len, false) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
switch (blend) {
@@ -17642,7 +19321,7 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
case WUFFS_BASE__PIXEL_FORMAT__BGR:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
@@ -17657,7 +19336,7 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
1024) {
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
@@ -17668,10 +19347,25 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=
WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) {
return NULL;
}
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__xxxxxxxx__index__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__xxxxxxxx__index_binary_alpha__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) != 256) {
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
switch (blend) {
@@ -17687,7 +19381,8 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(
dst_palette.ptr, dst_palette.len, NULL, 0, src_palette.ptr,
src_palette.len) != 256) {
src_palette.len) !=
(WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) {
return NULL;
}
switch (blend) {
@@ -17701,6 +19396,39 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(
return NULL;
}
static wuffs_base__pixel_swizzler__func //
wuffs_base__pixel_swizzler__prepare__bgr_565(
wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_format dst_pixfmt,
wuffs_base__slice_u8 dst_palette,
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
return wuffs_base__pixel_swizzler__copy_2_2;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
return wuffs_base__pixel_swizzler__bgr__bgr_565;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
return wuffs_base__pixel_swizzler__bgrw__bgr_565;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr_565;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
return wuffs_base__pixel_swizzler__rgbw__bgr_565;
}
return NULL;
}
static wuffs_base__pixel_swizzler__func //
wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_format dst_pixfmt,
@@ -17720,13 +19448,23 @@ wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
return wuffs_base__pixel_swizzler__bgrw__bgr;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
return wuffs_base__pixel_swizzler__bgrw_4x16le__bgr;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
return wuffs_base__pixel_swizzler__swap_rgb_bgr;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
break;
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__bgrw__rgb__sse42;
}
#endif
return wuffs_base__pixel_swizzler__bgrw__rgb;
}
return NULL;
}
@@ -17766,6 +19504,15 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -17781,8 +19528,32 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul(
break;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
// TODO.
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
#endif
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
@@ -17820,12 +19591,21 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__squash_tight_4x8_4x16le;
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul_4x16le__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__copy_8_8;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_nonpremul_4x16le__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -17841,8 +19621,27 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(
break;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
// TODO.
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__rgba_nonpremul__bgra_nonpremul_4x16le__src_over;
}
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__rgba_nonpremul_4x16le__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
@@ -17851,6 +19650,85 @@ wuffs_base__pixel_swizzler__prepare__bgra_nonpremul_4x16le(
return NULL;
}
static wuffs_base__pixel_swizzler__func //
wuffs_base__pixel_swizzler__prepare__bgra_premul(
wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_format dst_pixfmt,
wuffs_base__slice_u8 dst_palette,
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgr_565__bgra_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgr__bgra_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgr__bgra_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__bgra_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__copy_4_4;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
#endif
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;
}
return NULL;
}
return NULL;
}
static wuffs_base__pixel_swizzler__func //
wuffs_base__pixel_swizzler__prepare__bgrx(wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_format dst_pixfmt,
@@ -17869,16 +19747,21 @@ wuffs_base__pixel_swizzler__prepare__bgrx(wuffs_base__pixel_swizzler* p,
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
return wuffs_base__pixel_swizzler__bgrw__bgrx;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
return wuffs_base__pixel_swizzler__bgrw_4x16le__bgrx;
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
return wuffs_base__pixel_swizzler__copy_4_4;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
// TODO.
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
break;
return wuffs_base__pixel_swizzler__bgrw__rgbx;
}
return NULL;
}
@@ -17907,13 +19790,17 @@ wuffs_base__pixel_swizzler__prepare__rgb(wuffs_base__pixel_swizzler* p,
#endif
return wuffs_base__pixel_swizzler__bgrw__rgb;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
return wuffs_base__pixel_swizzler__bgrw_4x16le__rgb;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
return wuffs_base__pixel_swizzler__copy_3_3;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
break;
return wuffs_base__pixel_swizzler__bgrw__bgr;
}
return NULL;
}
@@ -17958,6 +19845,15 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
@@ -17973,8 +19869,27 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
break;
case WUFFS_BASE__PIXEL_FORMAT__RGB:
// TODO.
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__copy_4_4;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
// TODO.
@@ -17983,6 +19898,85 @@ wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
return NULL;
}
static wuffs_base__pixel_swizzler__func //
wuffs_base__pixel_swizzler__prepare__rgba_premul(
wuffs_base__pixel_swizzler* p,
wuffs_base__pixel_format dst_pixfmt,
wuffs_base__slice_u8 dst_palette,
wuffs_base__slice_u8 src_palette,
wuffs_base__pixel_blend blend) {
switch (dst_pixfmt.repr) {
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgr_565__rgba_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgr__rgba_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgr__rgba_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__rgba_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul_4x16le__rgba_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
if (wuffs_base__cpu_arch__have_x86_sse42()) {
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx__sse42;
}
#endif
return wuffs_base__pixel_swizzler__swap_rgbx_bgrx;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__rgba_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_nonpremul__bgra_premul__src_over;
}
return NULL;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
switch (blend) {
case WUFFS_BASE__PIXEL_BLEND__SRC:
return wuffs_base__pixel_swizzler__copy_4_4;
case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:
return wuffs_base__pixel_swizzler__bgra_premul__bgra_premul__src_over;
}
return NULL;
}
return NULL;
}
// --------
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
@@ -18055,6 +20049,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,
p, dst_pixfmt, dst_palette, src_palette, blend);
break;
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
func = wuffs_base__pixel_swizzler__prepare__bgr_565(
p, dst_pixfmt, dst_palette, src_palette, blend);
break;
case WUFFS_BASE__PIXEL_FORMAT__BGR:
func = wuffs_base__pixel_swizzler__prepare__bgr(
p, dst_pixfmt, dst_palette, src_palette, blend);
@@ -18070,6 +20069,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,
p, dst_pixfmt, dst_palette, src_palette, blend);
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
func = wuffs_base__pixel_swizzler__prepare__bgra_premul(
p, dst_pixfmt, dst_palette, src_palette, blend);
break;
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
func = wuffs_base__pixel_swizzler__prepare__bgrx(
p, dst_pixfmt, dst_palette, src_palette, blend);
@@ -18084,6 +20088,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,
func = wuffs_base__pixel_swizzler__prepare__rgba_nonpremul(
p, dst_pixfmt, dst_palette, src_palette, blend);
break;
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
func = wuffs_base__pixel_swizzler__prepare__rgba_premul(
p, dst_pixfmt, dst_palette, src_palette, blend);
break;
}
p->private_impl.func = func;
@@ -18623,6 +20632,7 @@ wuffs_adler32__hasher__up__choosy_default(
return wuffs_base__make_empty_struct();
}
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func adler32.hasher.up_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
@@ -18726,7 +20736,9 @@ wuffs_adler32__hasher__up_arm_neon(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func adler32.hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -18816,6 +20828,7 @@ wuffs_adler32__hasher__up_x86_sse42(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ADLER32)
@@ -22833,6 +24846,7 @@ wuffs_crc32__ieee_hasher__up__choosy_default(
return wuffs_base__make_empty_struct();
}
// ‼ WUFFS MULTI-FILE SECTION +arm_crc32
// -------- func crc32.ieee_hasher.up_arm_crc32
#if defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
@@ -22905,7 +24919,9 @@ wuffs_crc32__ieee_hasher__up_arm_crc32(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_CRC32)
// ‼ WUFFS MULTI-FILE SECTION -arm_crc32
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func crc32.ieee_hasher.up_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -23022,6 +25038,7 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__CRC32)
@@ -32544,6 +34561,7 @@ sizeof__wuffs_png__decoder() {
// ---------------- Function Implementations
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_1_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
@@ -32586,7 +34604,9 @@ wuffs_png__decoder__filter_1_distance_4_arm_neon(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_3_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
@@ -32675,7 +34695,9 @@ wuffs_png__decoder__filter_3_distance_4_arm_neon(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_4_distance_3_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
@@ -32793,7 +34815,9 @@ wuffs_png__decoder__filter_4_distance_3_arm_neon(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func png.decoder.filter_4_distance_4_arm_neon
#if defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
@@ -32891,6 +34915,7 @@ wuffs_png__decoder__filter_4_distance_4_arm_neon(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__ARM_NEON)
// ‼ WUFFS MULTI-FILE SECTION -arm_neon
// -------- func png.decoder.filter_1
@@ -33556,6 +35581,7 @@ wuffs_png__decoder__filter_4_distance_4_fallback(
return wuffs_base__make_empty_struct();
}
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_1_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -33599,7 +35625,9 @@ wuffs_png__decoder__filter_1_distance_4_x86_sse42(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_3_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -33702,7 +35730,9 @@ wuffs_png__decoder__filter_3_distance_4_x86_sse42(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_4_distance_3_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -33826,7 +35856,9 @@ wuffs_png__decoder__filter_4_distance_3_x86_sse42(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// ‼ WUFFS MULTI-FILE SECTION +x86_sse42
// -------- func png.decoder.filter_4_distance_4_x86_sse42
#if defined(WUFFS_BASE__CPU_ARCH__X86_64)
@@ -33928,6 +35960,7 @@ wuffs_png__decoder__filter_4_distance_4_x86_sse42(
return wuffs_base__make_empty_struct();
}
#endif // defined(WUFFS_BASE__CPU_ARCH__X86_64)
// ‼ WUFFS MULTI-FILE SECTION -x86_sse42
// -------- func png.decoder.set_quirk_enabled
@@ -36613,6 +38646,8 @@ namespace sync_io {
// --------
Input::~Input() {}
IOBuffer* //
Input::BringsItsOwnIOBuffer() {
return nullptr;
@@ -36703,6 +38738,8 @@ DecodeCborResult::DecodeCborResult(std::string&& error_message0,
: error_message(std::move(error_message0)),
cursor_position(cursor_position0) {}
DecodeCborCallbacks::~DecodeCborCallbacks() {}
void //
DecodeCborCallbacks::Done(DecodeCborResult& result,
sync_io::Input& input,
@@ -37030,29 +39067,39 @@ done:
namespace wuffs_aux {
DecodeImageResult::DecodeImageResult(MemOwner&& pixbuf_mem_owner0,
wuffs_base__slice_u8 pixbuf_mem_slice0,
wuffs_base__pixel_buffer pixbuf0,
std::string&& error_message0)
: pixbuf_mem_owner(std::move(pixbuf_mem_owner0)),
pixbuf_mem_slice(pixbuf_mem_slice0),
pixbuf(pixbuf0),
error_message(std::move(error_message0)) {}
DecodeImageResult::DecodeImageResult(std::string&& error_message0)
: pixbuf_mem_owner(nullptr, &free),
pixbuf_mem_slice(wuffs_base__empty_slice_u8()),
pixbuf(wuffs_base__null_pixel_buffer()),
error_message(std::move(error_message0)) {}
DecodeImageCallbacks::AllocResult::AllocResult(MemOwner&& mem_owner0,
wuffs_base__slice_u8 mem_slice0)
: mem_owner(std::move(mem_owner0)),
mem_slice(mem_slice0),
error_message("") {}
DecodeImageCallbacks::~DecodeImageCallbacks() {}
DecodeImageCallbacks::AllocResult::AllocResult(std::string&& error_message0)
DecodeImageCallbacks::AllocPixbufResult::AllocPixbufResult(
MemOwner&& mem_owner0,
wuffs_base__pixel_buffer pixbuf0)
: mem_owner(std::move(mem_owner0)), pixbuf(pixbuf0), error_message("") {}
DecodeImageCallbacks::AllocPixbufResult::AllocPixbufResult(
std::string&& error_message0)
: mem_owner(nullptr, &free),
mem_slice(wuffs_base__empty_slice_u8()),
pixbuf(wuffs_base__null_pixel_buffer()),
error_message(std::move(error_message0)) {}
DecodeImageCallbacks::AllocWorkbufResult::AllocWorkbufResult(
MemOwner&& mem_owner0,
wuffs_base__slice_u8 workbuf0)
: mem_owner(std::move(mem_owner0)), workbuf(workbuf0), error_message("") {}
DecodeImageCallbacks::AllocWorkbufResult::AllocWorkbufResult(
std::string&& error_message0)
: mem_owner(nullptr, &free),
workbuf(wuffs_base__empty_slice_u8()),
error_message(std::move(error_message0)) {}
wuffs_base__image_decoder::unique_ptr //
@@ -37095,45 +39142,54 @@ DecodeImageCallbacks::SelectDecoder(uint32_t fourcc,
wuffs_base__pixel_format //
DecodeImageCallbacks::SelectPixfmt(
const wuffs_base__image_config& image_config) {
return wuffs_base__make_pixel_format(
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL);
return wuffs_base__make_pixel_format(WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL);
}
DecodeImageCallbacks::AllocResult //
DecodeImageCallbacks::AllocPixbufResult //
DecodeImageCallbacks::AllocPixbuf(const wuffs_base__image_config& image_config,
bool allow_uninitialized_memory) {
uint32_t w = image_config.pixcfg.width();
uint32_t h = image_config.pixcfg.height();
if ((w == 0) || (h == 0)) {
return AllocResult("");
return AllocPixbufResult("");
}
uint64_t len = image_config.pixcfg.pixbuf_len();
if ((len == 0) || (SIZE_MAX < len)) {
return AllocResult(DecodeImage_UnsupportedPixelConfiguration);
return AllocPixbufResult(DecodeImage_UnsupportedPixelConfiguration);
}
void* ptr =
allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);
return ptr ? AllocResult(
MemOwner(ptr, &free),
wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len))
: AllocResult(DecodeImage_OutOfMemory);
if (!ptr) {
return AllocPixbufResult(DecodeImage_OutOfMemory);
}
wuffs_base__pixel_buffer pixbuf;
wuffs_base__status status = pixbuf.set_from_slice(
&image_config.pixcfg,
wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len));
if (!status.is_ok()) {
free(ptr);
return AllocPixbufResult(status.message());
}
return AllocPixbufResult(MemOwner(ptr, &free), pixbuf);
}
DecodeImageCallbacks::AllocResult //
DecodeImageCallbacks::AllocWorkbufResult //
DecodeImageCallbacks::AllocWorkbuf(wuffs_base__range_ii_u64 len_range,
bool allow_uninitialized_memory) {
uint64_t len = len_range.max_incl;
if (len == 0) {
return AllocResult("");
return AllocWorkbufResult("");
} else if (SIZE_MAX < len) {
return AllocResult(DecodeImage_OutOfMemory);
return AllocWorkbufResult(DecodeImage_OutOfMemory);
}
void* ptr =
allow_uninitialized_memory ? malloc((size_t)len) : calloc((size_t)len, 1);
return ptr ? AllocResult(
MemOwner(ptr, &free),
wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len))
: AllocResult(DecodeImage_OutOfMemory);
if (!ptr) {
return AllocWorkbufResult(DecodeImage_OutOfMemory);
}
return AllocWorkbufResult(
MemOwner(ptr, &free),
wuffs_base__make_slice_u8((uint8_t*)ptr, (size_t)len));
}
void //
@@ -37303,7 +39359,10 @@ redirect:
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__RGBA_NONPREMUL:
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
break;
default:
return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);
@@ -37313,28 +39372,14 @@ redirect:
}
// Allocate the pixel buffer.
uint64_t pixbuf_len_min_incl = 0;
if ((w > 0) && (h > 0)) {
pixbuf_len_min_incl = image_config.pixcfg.pixbuf_len();
if (pixbuf_len_min_incl == 0) {
return DecodeImageResult(DecodeImage_UnsupportedPixelFormat);
}
}
bool valid_background_color =
wuffs_base__color_u32_argb_premul__is_valid(background_color);
DecodeImageCallbacks::AllocResult alloc_pixbuf_result =
DecodeImageCallbacks::AllocPixbufResult alloc_pixbuf_result =
callbacks.AllocPixbuf(image_config, valid_background_color);
if (!alloc_pixbuf_result.error_message.empty()) {
return DecodeImageResult(std::move(alloc_pixbuf_result.error_message));
} else if (alloc_pixbuf_result.mem_slice.len < pixbuf_len_min_incl) {
return DecodeImageResult(DecodeImage_BufferIsTooShort);
}
wuffs_base__pixel_buffer pixel_buffer;
wuffs_base__status pb_sfs_status = pixel_buffer.set_from_slice(
&image_config.pixcfg, alloc_pixbuf_result.mem_slice);
if (!pb_sfs_status.is_ok()) {
return DecodeImageResult(pb_sfs_status.message());
}
wuffs_base__pixel_buffer pixel_buffer = alloc_pixbuf_result.pixbuf;
if (valid_background_color) {
wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(
pixel_buffer.pixcfg.bounds(), background_color);
@@ -37346,11 +39391,11 @@ redirect:
// Allocate the work buffer. Wuffs' decoders conventionally assume that this
// can be uninitialized memory.
wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();
DecodeImageCallbacks::AllocResult alloc_workbuf_result =
DecodeImageCallbacks::AllocWorkbufResult alloc_workbuf_result =
callbacks.AllocWorkbuf(workbuf_len, true);
if (!alloc_workbuf_result.error_message.empty()) {
return DecodeImageResult(std::move(alloc_workbuf_result.error_message));
} else if (alloc_workbuf_result.mem_slice.len < workbuf_len.min_incl) {
} else if (alloc_workbuf_result.workbuf.len < workbuf_len.min_incl) {
return DecodeImageResult(DecodeImage_BufferIsTooShort);
}
@@ -37385,7 +39430,7 @@ redirect:
while (true) {
wuffs_base__status id_df_status =
image_decoder->decode_frame(&pixel_buffer, &io_buf, pixel_blend,
alloc_workbuf_result.mem_slice, nullptr);
alloc_workbuf_result.workbuf, nullptr);
if (id_df_status.repr == nullptr) {
break;
} else if (id_df_status.repr != wuffs_base__suspension__short_read) {
@@ -37403,8 +39448,7 @@ redirect:
}
}
return DecodeImageResult(std::move(alloc_pixbuf_result.mem_owner),
alloc_pixbuf_result.mem_slice, pixel_buffer,
std::move(message));
pixel_buffer, std::move(message));
}
} // namespace
@@ -37451,6 +39495,8 @@ DecodeJsonResult::DecodeJsonResult(std::string&& error_message0,
: error_message(std::move(error_message0)),
cursor_position(cursor_position0) {}
DecodeJsonCallbacks::~DecodeJsonCallbacks() {}
void //
DecodeJsonCallbacks::Done(DecodeJsonResult& result,
sync_io::Input& input,
@@ -37969,8 +40015,8 @@ done:
#endif // WUFFS_IMPLEMENTATION
#ifdef __clang__
#pragma clang diagnostic pop
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
#endif // WUFFS_INCLUDE_GUARD