diff --git a/release/c/wuffs-v0.3.c b/release/c/wuffs-v0.3.c index 7d4d9d73..bb5a693a 100644 --- a/release/c/wuffs-v0.3.c +++ b/release/c/wuffs-v0.3.c @@ -10,10 +10,15 @@ // Wuffs' C code is generated automatically, not hand-written. These warnings' // costs outweigh the benefits. -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wunreachable-code" -#pragma clang diagnostic ignored "-Wunused-function" +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#pragma GCC diagnostic ignored "-Wunreachable-code" +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wunused-parameter" +#if defined(__cplusplus) +#pragma GCC diagnostic ignored "-Wold-style-cast" +#endif #endif // Copyright 2017 The Wuffs Authors. @@ -65,15 +70,15 @@ 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