From 4a83eba3f93443a0624c24df3fc01eb40da2f31a Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Fri, 24 Jan 2020 11:32:13 +1100 Subject: [PATCH] Add WUFFS_BASE__PIXEL_BLEND__SRC_OVER --- example/imageviewer/imageviewer.c | 23 ++- internal/cgen/base/image-impl.c | 211 +++++++++++++++++++++--- internal/cgen/base/image-public.h | 1 + internal/cgen/data.go | 26 +-- release/c/wuffs-unsupported-snapshot.c | 212 ++++++++++++++++++++++--- 5 files changed, 421 insertions(+), 52 deletions(-) diff --git a/example/imageviewer/imageviewer.c b/example/imageviewer/imageviewer.c index 82c869a5..17338bed 100644 --- a/example/imageviewer/imageviewer.c +++ b/example/imageviewer/imageviewer.c @@ -80,12 +80,20 @@ uint8_t g_src_buffer[SRC_BUFFER_SIZE] = {0}; wuffs_base__io_buffer g_src = {0}; wuffs_base__image_config g_image_config = {0}; wuffs_base__image_decoder* g_image_decoder = NULL; +wuffs_base__color_u32_argb_premul g_background_color = 0xFFA9009A; union { wuffs_gif__decoder gif; wuffs_wbmp__decoder wbmp; } g_potential_decoders; +static inline void store_u32le(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); +} + bool read_more_src() { if (g_src.meta.closed) { printf("%s: unexpected end of file\n", g_filename); @@ -191,7 +199,7 @@ bool load_image_config() { printf("%s: out of memory\n", g_filename); return false; } - g_workbuf_slice.ptr = p; + g_workbuf_slice.ptr = (uint8_t*)p; g_workbuf_slice.len = workbuf_len; } @@ -202,12 +210,19 @@ bool load_image_config() { return false; } size_t n = num_pixels * sizeof(wuffs_base__color_u32_argb_premul); - void* p = calloc(n, 1); + void* p = malloc(n); if (!p) { printf("%s: out of memory\n", g_filename); return false; } - g_pixbuf_slice.ptr = p; + { + uint8_t* ptr = (uint8_t*)p; + for (size_t i = 0; i < num_pixels; i++) { + store_u32le(ptr, g_background_color); + ptr += 4; + } + } + g_pixbuf_slice.ptr = (uint8_t*)p; g_pixbuf_slice.len = n; // Configure the wuffs_base__pixel_buffer struct. @@ -226,7 +241,7 @@ bool load_image_config() { bool load_image_frame() { while (true) { wuffs_base__status status = wuffs_base__image_decoder__decode_frame( - g_image_decoder, &g_pixbuf, &g_src, WUFFS_BASE__PIXEL_BLEND__SRC, + g_image_decoder, &g_pixbuf, &g_src, WUFFS_BASE__PIXEL_BLEND__SRC_OVER, g_workbuf_slice, NULL); if (status.repr == NULL) { diff --git a/internal/cgen/base/image-impl.c b/internal/cgen/base/image-impl.c index 35105cc6..e7dcb865 100644 --- a/internal/cgen/base/image-impl.c +++ b/internal/cgen/base/image-impl.c @@ -29,9 +29,9 @@ wuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst, } static uint64_t // -wuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 dst_palette, - wuffs_base__slice_u8 src) { +wuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { if (dst_palette.len != 1024) { return 0; } @@ -70,11 +70,11 @@ wuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst, } while (n >= 1) { - uint32_t color = + uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); - d[0] = (uint8_t)(color >> 0); - d[1] = (uint8_t)(color >> 8); - d[2] = (uint8_t)(color >> 16); + d[0] = (uint8_t)(s0 >> 0); + d[1] = (uint8_t)(s0 >> 8); + d[2] = (uint8_t)(s0 >> 16); s += 1 * 1; d += 3 * 1; @@ -85,9 +85,68 @@ wuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst, } static uint64_t // -wuffs_base__pixel_swizzler__xxxx_index(wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 dst_palette, - wuffs_base__slice_u8 src) { +wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over( + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { + if (dst_palette.len != 1024) { + return 0; + } + size_t dst_len3 = dst.len / 3; + size_t len = dst_len3 < src.len ? dst_len3 : src.len; + uint8_t* d = dst.ptr; + uint8_t* s = src.ptr; + size_t n = len; + + // N is the loop unroll count. + const int N = 4; + + while (n >= N) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u24le(d + (0 * 4), s0); + } + uint32_t s1 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)); + if (s1) { + wuffs_base__store_u24le(d + (1 * 4), s1); + } + uint32_t s2 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)); + if (s2) { + wuffs_base__store_u24le(d + (2 * 4), s2); + } + uint32_t s3 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)); + if (s3) { + wuffs_base__store_u24le(d + (3 * 4), s3); + } + + s += 1 * N; + d += 3 * N; + n -= (size_t)(1 * N); + } + + while (n >= 1) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u24le(d + (0 * 4), s0); + } + + s += 1 * 1; + d += 3 * 1; + n -= (size_t)(1 * 1); + } + + return len; +} + +static uint64_t // +wuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { if (dst_palette.len != 1024) { return 0; } @@ -133,9 +192,68 @@ wuffs_base__pixel_swizzler__xxxx_index(wuffs_base__slice_u8 dst, } static uint64_t // -wuffs_base__pixel_swizzler__xxxx_y(wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 dst_palette, - wuffs_base__slice_u8 src) { +wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { + if (dst_palette.len != 1024) { + return 0; + } + size_t dst_len4 = dst.len / 4; + size_t len = dst_len4 < src.len ? dst_len4 : src.len; + uint8_t* d = dst.ptr; + uint8_t* s = src.ptr; + size_t n = len; + + // N is the loop unroll count. + const int N = 4; + + while (n >= N) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u32le(d + (0 * 4), s0); + } + uint32_t s1 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)); + if (s1) { + wuffs_base__store_u32le(d + (1 * 4), s1); + } + uint32_t s2 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)); + if (s2) { + wuffs_base__store_u32le(d + (2 * 4), s2); + } + uint32_t s3 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)); + if (s3) { + wuffs_base__store_u32le(d + (3 * 4), s3); + } + + s += 1 * N; + d += 4 * N; + n -= (size_t)(1 * N); + } + + while (n >= 1) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u32le(d + (0 * 4), s0); + } + + s += 1 * 1; + d += 4 * 1; + n -= (size_t)(1 * 1); + } + + return len; +} + +static uint64_t // +wuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { size_t dst_len4 = dst.len / 4; size_t len = dst_len4 < src.len ? dst_len4 : src.len; uint8_t* d = dst.ptr; @@ -179,6 +297,8 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx(wuffs_base__slice_u8 dst, return len4 * 4; } +// -------- + wuffs_base__status // wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, wuffs_base__pixel_format dst_format, @@ -202,6 +322,7 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, case WUFFS_BASE__PIXEL_FORMAT__RGB: // TODO. break; + case WUFFS_BASE__PIXEL_FORMAT__BGRX: case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: @@ -210,8 +331,9 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: - func = wuffs_base__pixel_swizzler__xxxx_y; + func = wuffs_base__pixel_swizzler__xxxx__y; break; + default: break; } @@ -226,15 +348,33 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, 1024) { break; } - func = wuffs_base__pixel_swizzler__copy_1_1; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__copy_1_1; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__BGR: if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) != 1024) { break; } - func = wuffs_base__pixel_swizzler__xxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: @@ -242,15 +382,37 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, 1024) { break; } - func = wuffs_base__pixel_swizzler__xxxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__RGB: if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette, src_palette) != 1024) { break; } - func = wuffs_base__pixel_swizzler__xxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: @@ -258,8 +420,19 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, src_palette) != 1024) { break; } - func = wuffs_base__pixel_swizzler__xxxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + default: break; } diff --git a/internal/cgen/base/image-public.h b/internal/cgen/base/image-public.h index 27700db4..bdd49e21 100644 --- a/internal/cgen/base/image-public.h +++ b/internal/cgen/base/image-public.h @@ -31,6 +31,7 @@ typedef uint8_t wuffs_base__pixel_blend; // // TODO: implement the other modes. #define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) +#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) // -------- diff --git a/internal/cgen/data.go b/internal/cgen/data.go index 4981225b..ca4090c5 100644 --- a/internal/cgen/data.go +++ b/internal/cgen/data.go @@ -26,15 +26,21 @@ const baseAllImplC = "" + "" const baseImageImplC = "" + - "// ---------------- Images\n\nconst uint32_t wuffs_base__pixel_format__bits_per_channel[16] = {\n 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,\n};\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n return wuffs_base__slice_u8__copy_from_slice(dst, src);\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // N is the loop unroll count.\n const int N = 4;\n\n // The comparison in the while condition is \">\", not \">=\"," + - " because with \">=\",\n // the last 4-byte store could write past the end of the dst slice.\n //\n // Each 4-byte store writes one too many bytes, but a subsequent store will\n // overwrite that with the correct byte. There is always another store,\n // whether a 4-byte store in this loop or a 1-byte store in the next loop.\n while (n > N) {\n wuffs_base__store_u32le(\n d + (0 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)));\n wuffs_base__store_u32le(\n d + (1 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)));\n wuffs_base__store_u32le(\n d + (2 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)));\n wuffs_base__store_u32le(\n d + (3 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)));\n\n s += 1 * N;\n d += 3 * N;\n n -= (size_t)(1 * N);\n }\n\n while (n >= 1) {\n uint32_t color =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4));\n " + - "d[0] = (uint8_t)(color >> 0);\n d[1] = (uint8_t)(color >> 8);\n d[2] = (uint8_t)(color >> 16);\n\n s += 1 * 1;\n d += 3 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx_index(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // N is the loop unroll count.\n const int N = 4;\n\n while (n >= N) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)));\n wuffs_base__store_u32le(\n d + (1 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)));\n wuffs_base__store_u32le(\n d + (2 * 4),\n wuffs_base__load_u32le(dst_palet" + - "te.ptr + ((uint32_t)(s[2]) * 4)));\n wuffs_base__store_u32le(\n d + (3 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)));\n\n s += 1 * N;\n d += 4 * N;\n n -= (size_t)(1 * N);\n }\n\n while (n >= 1) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)));\n\n s += 1 * 1;\n d += 4 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx_y(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__store_u32le(d + (0 * 4),\n 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 4 * 1;\n n -= (size_t)(1 * " + - "1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t len4 = (dst.len < src.len ? dst.len : src.len) / 4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n\n size_t n = len4;\n while (n--) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n uint8_t b3 = s[3];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = b3;\n s += 4;\n d += 4;\n }\n return len4 * 4;\n}\n\nwuffs_base__status //\nwuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_format,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n if (!p) {\n return wuffs_base__make_status" + - "(wuffs_base__error__bad_receiver);\n }\n\n // TODO: support many more formats.\n\n uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) = NULL;\n\n switch (src_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n func = wuffs_base__pixel_swizzler__xxxx_y;\n break;\n default:\n break;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINAR" + - "Y:\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n break;\n }\n func = wuffs_base__pixel_swizzler__copy_1_1;\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n break;\n }\n func = wuffs_base__pixel_swizzler__xxx_index;\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n break;\n }\n func = wuffs_base__pixel_swizzler__xxxx_in" + - "dex;\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette,\n src_palette) != 1024) {\n break;\n }\n func = wuffs_base__pixel_swizzler__xxx_index;\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette,\n src_palette) != 1024) {\n break;\n }\n func = wuffs_base__pixel_swizzler__xxxx_index;\n break;\n default:\n break;\n }\n break;\n\n default:\n break;\n }\n\n p->private_impl.func = func;\n return wuffs_base__make_status(func ? NULL\n : wuffs_base__error__unsupported_option);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler__s" + - "wizzle_interleaved(\n const wuffs_base__pixel_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (p && p->private_impl.func) {\n return (*(p->private_impl.func))(dst, dst_palette, src);\n }\n return 0;\n}\n" + + "// ---------------- Images\n\nconst uint32_t wuffs_base__pixel_format__bits_per_channel[16] = {\n 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,\n};\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n return wuffs_base__slice_u8__copy_from_slice(dst, src);\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // N is the loop unroll count.\n const int N = 4;\n\n // The comparison in the while condition" + + " is \">\", not \">=\", because with \">=\",\n // the last 4-byte store could write past the end of the dst slice.\n //\n // Each 4-byte store writes one too many bytes, but a subsequent store will\n // overwrite that with the correct byte. There is always another store,\n // whether a 4-byte store in this loop or a 1-byte store in the next loop.\n while (n > N) {\n wuffs_base__store_u32le(\n d + (0 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)));\n wuffs_base__store_u32le(\n d + (1 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)));\n wuffs_base__store_u32le(\n d + (2 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)));\n wuffs_base__store_u32le(\n d + (3 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)));\n\n s += 1 * N;\n d += 3 * N;\n n -= (size_t)(1 * N);\n }\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[" + + "0]) * 4));\n d[0] = (uint8_t)(s0 >> 0);\n d[1] = (uint8_t)(s0 >> 8);\n d[2] = (uint8_t)(s0 >> 16);\n\n s += 1 * 1;\n d += 3 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // N is the loop unroll count.\n const int N = 4;\n\n while (n >= N) {\n uint32_t s0 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4));\n if (s0) {\n wuffs_base__store_u24le(d + (0 * 4), s0);\n }\n uint32_t s1 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4));\n if (s1) {\n wuffs_base__store_u24le(d + (1 * 4), s1);\n }\n uint32_t s2 =\n wuffs_base__load_u32le(dst_pal" + + "ette.ptr + ((uint32_t)(s[2]) * 4));\n if (s2) {\n wuffs_base__store_u24le(d + (2 * 4), s2);\n }\n uint32_t s3 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4));\n if (s3) {\n wuffs_base__store_u24le(d + (3 * 4), s3);\n }\n\n s += 1 * N;\n d += 3 * N;\n n -= (size_t)(1 * N);\n }\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4));\n if (s0) {\n wuffs_base__store_u24le(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 3 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n siz" + + "e_t n = len;\n\n // N is the loop unroll count.\n const int N = 4;\n\n while (n >= N) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)));\n wuffs_base__store_u32le(\n d + (1 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)));\n wuffs_base__store_u32le(\n d + (2 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)));\n wuffs_base__store_u32le(\n d + (3 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)));\n\n s += 1 * N;\n d += 4 * N;\n n -= (size_t)(1 * N);\n }\n\n while (n >= 1) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)));\n\n s += 1 * 1;\n d += 4 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palett" + + "e,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // N is the loop unroll count.\n const int N = 4;\n\n while (n >= N) {\n uint32_t s0 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4));\n if (s0) {\n wuffs_base__store_u32le(d + (0 * 4), s0);\n }\n uint32_t s1 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4));\n if (s1) {\n wuffs_base__store_u32le(d + (1 * 4), s1);\n }\n uint32_t s2 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4));\n if (s2) {\n wuffs_base__store_u32le(d + (2 * 4), s2);\n }\n uint32_t s3 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4));\n if (s3) {\n wuffs_base__store_u32le(d + (3 * 4), s3);\n }\n\n s += 1 * N;\n d += 4 * N;\n n -= (size_t)(1 * N);\n }\n\n whil" + + "e (n >= 1) {\n uint32_t s0 =\n wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4));\n if (s0) {\n wuffs_base__store_u32le(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 4 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__store_u32le(d + (0 * 4),\n 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 4 * 1;\n n -= (size_t)(1 * 1);\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size" + + "_t len4 = (dst.len < src.len ? dst.len : src.len) / 4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n\n size_t n = len4;\n while (n--) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n uint8_t b3 = s[3];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = b3;\n s += 4;\n d += 4;\n }\n return len4 * 4;\n}\n\n" + + "" + + "// --------\n\nwuffs_base__status //\nwuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__pixel_format src_format,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n if (!p) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n\n // TODO: support many more formats.\n\n uint64_t (*func)(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) = NULL;\n\n switch (src_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT_" + + "_BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n func = wuffs_base__pixel_swizzler__xxxx__y;\n break;\n\n default:\n break;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n break;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n func = wuffs_base__pixel_swizzler__copy_1_1;\n break;\n " + + " default:\n break;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n break;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n func = wuffs_base__pixel_swizzler__xxx__index__src;\n break;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n func =\n wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n break;\n default:\n break;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n break;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n " + + " func = wuffs_base__pixel_swizzler__xxxx__index__src;\n break;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n func =\n wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n break;\n default:\n break;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette,\n src_palette) != 1024) {\n break;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n func = wuffs_base__pixel_swizzler__xxx__index__src;\n break;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n func =\n wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n break;\n default:\n break;\n }\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n " + + " case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette,\n src_palette) != 1024) {\n break;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n func = wuffs_base__pixel_swizzler__xxxx__index__src;\n break;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n func =\n wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n break;\n default:\n break;\n }\n break;\n\n default:\n break;\n }\n break;\n\n default:\n break;\n }\n\n p->private_impl.func = func;\n return wuffs_base__make_status(func ? NULL\n : wuffs_base__error__unsupported_option);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler__swizzle_interleaved(\n const wuffs_base__pix" + + "el_swizzler* p,\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (p && p->private_impl.func) {\n return (*(p->private_impl.func))(dst, dst_palette, src);\n }\n return 0;\n}\n" + "" const baseCorePrivateH = "" + @@ -112,7 +118,7 @@ const baseImagePrivateH = "" + const baseImagePublicH = "" + "// ---------------- Images\n\n// wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied\n// Alpha, Red, Green, Blue color, as a uint32_t value. It is in word order, not\n// byte order: its value is always 0xAARRGGBB, regardless of endianness.\ntypedef uint32_t wuffs_base__color_u32_argb_premul;\n\n" + "" + - "// --------\n\ntypedef uint8_t wuffs_base__pixel_blend;\n\n// wuffs_base__pixel_blend encodes how to blend source and destination pixels,\n// accounting for transparency. It encompasses the Porter-Duff compositing\n// operators as well as the other blending modes defined by PDF.\n//\n// TODO: implement the other modes.\n#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)\n\n" + + "// --------\n\ntypedef uint8_t wuffs_base__pixel_blend;\n\n// wuffs_base__pixel_blend encodes how to blend source and destination pixels,\n// accounting for transparency. It encompasses the Porter-Duff compositing\n// operators as well as the other blending modes defined by PDF.\n//\n// TODO: implement the other modes.\n#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)\n#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)\n\n" + "" + "// --------\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data.\n//\n// See https://github.com/google/wuffs/blob/master/doc/note/pixel-formats.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef struct {\n uint32_t repr;\n\n#ifdef __cplusplus\n inline bool is_valid() const;\n inline uint32_t bits_per_pixel() const;\n inline bool is_indexed() const;\n inline bool is_interleaved() const;\n inline bool is_planar() const;\n inline uint32_t num_planes() const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_format;\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__make_pixel_format(uint32_t repr) {\n wuffs_base__pixel_format f;\n f.repr = repr;\n return f;\n}\n\n // Common 8-bit-depth pixel formats. This list is not exhaustive; not all\n // valid wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID 0x00000000\n\n#define" + " WUFFS_BASE__PIXEL_FORMAT__A 0x02000008\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y 0x10000008\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL 0x15000008\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL 0x16000008\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCR 0x20020888\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRK 0x21038888\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRA_NONPREMUL 0x25038888\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCG 0x30020888\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCGK 0x31038888\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCGA_NONPREMUL 0x35038888\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL 0x45040008\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL 0x46040008\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY 0x47040008\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR 0x40000888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX 0x41008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL 0x45008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL 0x46008888\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY 0x47008888\n\n#define WUFFS_" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 520a11a0..eba6b835 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -1483,6 +1483,7 @@ typedef uint8_t wuffs_base__pixel_blend; // // TODO: implement the other modes. #define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0) +#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1) // -------- @@ -5818,9 +5819,9 @@ wuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst, } static uint64_t // -wuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 dst_palette, - wuffs_base__slice_u8 src) { +wuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { if (dst_palette.len != 1024) { return 0; } @@ -5859,11 +5860,11 @@ wuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst, } while (n >= 1) { - uint32_t color = + uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); - d[0] = (uint8_t)(color >> 0); - d[1] = (uint8_t)(color >> 8); - d[2] = (uint8_t)(color >> 16); + d[0] = (uint8_t)(s0 >> 0); + d[1] = (uint8_t)(s0 >> 8); + d[2] = (uint8_t)(s0 >> 16); s += 1 * 1; d += 3 * 1; @@ -5874,9 +5875,68 @@ wuffs_base__pixel_swizzler__xxx_index(wuffs_base__slice_u8 dst, } static uint64_t // -wuffs_base__pixel_swizzler__xxxx_index(wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 dst_palette, - wuffs_base__slice_u8 src) { +wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over( + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { + if (dst_palette.len != 1024) { + return 0; + } + size_t dst_len3 = dst.len / 3; + size_t len = dst_len3 < src.len ? dst_len3 : src.len; + uint8_t* d = dst.ptr; + uint8_t* s = src.ptr; + size_t n = len; + + // N is the loop unroll count. + const int N = 4; + + while (n >= N) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u24le(d + (0 * 4), s0); + } + uint32_t s1 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)); + if (s1) { + wuffs_base__store_u24le(d + (1 * 4), s1); + } + uint32_t s2 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)); + if (s2) { + wuffs_base__store_u24le(d + (2 * 4), s2); + } + uint32_t s3 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)); + if (s3) { + wuffs_base__store_u24le(d + (3 * 4), s3); + } + + s += 1 * N; + d += 3 * N; + n -= (size_t)(1 * N); + } + + while (n >= 1) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u24le(d + (0 * 4), s0); + } + + s += 1 * 1; + d += 3 * 1; + n -= (size_t)(1 * 1); + } + + return len; +} + +static uint64_t // +wuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { if (dst_palette.len != 1024) { return 0; } @@ -5922,9 +5982,68 @@ wuffs_base__pixel_swizzler__xxxx_index(wuffs_base__slice_u8 dst, } static uint64_t // -wuffs_base__pixel_swizzler__xxxx_y(wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 dst_palette, - wuffs_base__slice_u8 src) { +wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { + if (dst_palette.len != 1024) { + return 0; + } + size_t dst_len4 = dst.len / 4; + size_t len = dst_len4 < src.len ? dst_len4 : src.len; + uint8_t* d = dst.ptr; + uint8_t* s = src.ptr; + size_t n = len; + + // N is the loop unroll count. + const int N = 4; + + while (n >= N) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u32le(d + (0 * 4), s0); + } + uint32_t s1 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[1]) * 4)); + if (s1) { + wuffs_base__store_u32le(d + (1 * 4), s1); + } + uint32_t s2 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[2]) * 4)); + if (s2) { + wuffs_base__store_u32le(d + (2 * 4), s2); + } + uint32_t s3 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[3]) * 4)); + if (s3) { + wuffs_base__store_u32le(d + (3 * 4), s3); + } + + s += 1 * N; + d += 4 * N; + n -= (size_t)(1 * N); + } + + while (n >= 1) { + uint32_t s0 = + wuffs_base__load_u32le(dst_palette.ptr + ((uint32_t)(s[0]) * 4)); + if (s0) { + wuffs_base__store_u32le(d + (0 * 4), s0); + } + + s += 1 * 1; + d += 4 * 1; + n -= (size_t)(1 * 1); + } + + return len; +} + +static uint64_t // +wuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src) { size_t dst_len4 = dst.len / 4; size_t len = dst_len4 < src.len ? dst_len4 : src.len; uint8_t* d = dst.ptr; @@ -5968,6 +6087,8 @@ wuffs_base__pixel_swizzler__swap_rgbx_bgrx(wuffs_base__slice_u8 dst, return len4 * 4; } +// -------- + wuffs_base__status // wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, wuffs_base__pixel_format dst_format, @@ -5991,6 +6112,7 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, case WUFFS_BASE__PIXEL_FORMAT__RGB: // TODO. break; + case WUFFS_BASE__PIXEL_FORMAT__BGRX: case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: @@ -5999,8 +6121,9 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: - func = wuffs_base__pixel_swizzler__xxxx_y; + func = wuffs_base__pixel_swizzler__xxxx__y; break; + default: break; } @@ -6015,15 +6138,33 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, 1024) { break; } - func = wuffs_base__pixel_swizzler__copy_1_1; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__copy_1_1; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__BGR: if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) != 1024) { break; } - func = wuffs_base__pixel_swizzler__xxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: @@ -6031,15 +6172,37 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, 1024) { break; } - func = wuffs_base__pixel_swizzler__xxxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__RGB: if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette, src_palette) != 1024) { break; } - func = wuffs_base__pixel_swizzler__xxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: @@ -6047,8 +6210,19 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, src_palette) != 1024) { break; } - func = wuffs_base__pixel_swizzler__xxxx_index; + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + func = wuffs_base__pixel_swizzler__xxxx__index__src; + break; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + func = + wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over; + break; + default: + break; + } break; + default: break; }