wuffs gen -version=0.3.0-beta.1
diff --git a/release/c/wuffs-v0.3.c b/release/c/wuffs-v0.3.c
index 7d4d9d7..bb5a693 100644
--- a/release/c/wuffs-v0.3.c
+++ b/release/c/wuffs-v0.3.c
@@ -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 @@
// 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 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__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.
@@ -1289,6 +1288,58 @@
}
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;
ret.ptr = NULL;
@@ -1369,6 +1420,45 @@
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 @@
#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 @@
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 @@
} 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;
@@ -4304,6 +4402,55 @@
}
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,
wuffs_base__slice_u8 pixbuf_memory) {
@@ -4329,11 +4476,12 @@
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 @@
&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 @@
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 @@
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__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__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;
@@ -4477,6 +4635,15 @@
#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,
wuffs_base__slice_u8 pixbuf_memory) {
@@ -4487,9 +4654,9 @@
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 @@
class Input {
public:
+ virtual ~Input();
+
virtual IOBuffer* BringsItsOwnIOBuffer();
virtual std::string CopyIn(IOBuffer* dst) = 0;
};
@@ -9432,6 +9601,8 @@
class DecodeCborCallbacks {
public:
+ virtual ~DecodeCborCallbacks();
+
// AppendXxx are called for leaf nodes: literals, numbers, strings, etc.
virtual std::string AppendNull() = 0;
@@ -9492,13 +9663,11 @@
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 @@
// 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 @@
// - 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 @@
// 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 @@
// 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 @@
//
// 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 @@
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 @@
#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 @@
// 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 @@
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_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 @@
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 @@
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 @@
}
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 @@
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;
}
@@ -15574,34 +15816,6 @@
// --------
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,
uint8_t* dst_palette_ptr,
@@ -15616,6 +15830,22 @@
}
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,
uint8_t* dst_palette_ptr,
@@ -15647,6 +15877,22 @@
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 //
@@ -15888,6 +16134,91 @@
}
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,
uint8_t* dst_palette_ptr,
@@ -16008,6 +16339,93 @@
}
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,
uint8_t* dst_palette_ptr,
@@ -16073,7 +16491,8 @@
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 @@
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 @@
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;
@@ -16190,6 +16611,35 @@
// --------
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,
uint8_t* dst_palette_ptr,
@@ -16347,6 +16797,81 @@
}
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,
uint8_t* dst_palette_ptr,
@@ -16424,6 +16949,81 @@
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 //
@@ -16457,6 +17057,33 @@
}
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,
size_t dst_len,
@@ -16489,6 +17116,64 @@
}
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,
size_t dst_len,
@@ -16496,7 +17181,8 @@
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 @@
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 //
@@ -16684,6 +17745,37 @@
}
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,
size_t dst_len,
@@ -16691,7 +17783,8 @@
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 @@
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 //
@@ -16813,6 +18004,35 @@
}
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,
uint8_t* dst_palette_ptr,
@@ -16841,8 +18061,9 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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,
@@ -17385,6 +18878,126 @@
// --------
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,
uint8_t* dst_palette_ptr,
@@ -17474,6 +19087,12 @@
}
#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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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) {
@@ -17702,6 +19397,39 @@
}
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,
wuffs_base__slice_u8 dst_palette,
@@ -17720,13 +19448,23 @@
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 @@
}
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 @@
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 @@
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 @@
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.
@@ -17852,6 +19651,85 @@
}
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,
wuffs_base__slice_u8 dst_palette,
@@ -17869,16 +19747,21 @@
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 @@
#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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// ---------------- 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// --------
+Input::~Input() {}
+
IOBuffer* //
Input::BringsItsOwnIOBuffer() {
return nullptr;
@@ -36703,6 +38738,8 @@
: 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 @@
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 @@
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 @@
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 @@
}
// 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 @@
// 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 @@
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 @@
}
}
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 @@
: 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 @@
#endif // WUFFS_IMPLEMENTATION
-#ifdef __clang__
-#pragma clang diagnostic pop
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
#endif
#endif // WUFFS_INCLUDE_GUARD
