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