From 4feb641841a07ca77c7ffa101895fbe19e636d28 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 16 Jan 2020 15:02:32 +1100 Subject: [PATCH] Implement wbmp.decoder.decode_frame --- example/imageviewer/imageviewer.c | 15 +++ internal/cgen/base/image-impl.c | 46 ++++++++ internal/cgen/data.go | 16 +-- release/c/wuffs-unsupported-snapshot.c | 143 +++++++++++++++++++++++++ std/wbmp/decode_wbmp.wuffs | 59 +++++++++- test/c/std/wbmp.c | 13 +++ 6 files changed, 283 insertions(+), 9 deletions(-) diff --git a/example/imageviewer/imageviewer.c b/example/imageviewer/imageviewer.c index 0f95fc34..82c869a5 100644 --- a/example/imageviewer/imageviewer.c +++ b/example/imageviewer/imageviewer.c @@ -55,6 +55,7 @@ The Escape key quits. #define WUFFS_CONFIG__MODULE__BASE #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__LZW +#define WUFFS_CONFIG__MODULE__WBMP // If building this program in an environment that doesn't easily accommodate // relative includes, you can use the script/inline-c-relative-includes.go @@ -82,6 +83,7 @@ wuffs_base__image_decoder* g_image_decoder = NULL; union { wuffs_gif__decoder gif; + wuffs_wbmp__decoder wbmp; } g_potential_decoders; bool read_more_src() { @@ -110,6 +112,19 @@ bool load_image_type() { wuffs_base__status status; switch (g_src_buffer[0]) { + case '\x00': + status = wuffs_wbmp__decoder__initialize( + &g_potential_decoders.wbmp, sizeof g_potential_decoders.wbmp, + WUFFS_VERSION, WUFFS_INITIALIZE__DEFAULT_OPTIONS); + if (!wuffs_base__status__is_ok(&status)) { + printf("%s: %s\n", g_filename, wuffs_base__status__message(&status)); + return false; + } + g_image_decoder = + wuffs_wbmp__decoder__upcast_as__wuffs_base__image_decoder( + &g_potential_decoders.wbmp); + break; + case 'G': status = wuffs_gif__decoder__initialize( &g_potential_decoders.gif, sizeof g_potential_decoders.gif, diff --git a/internal/cgen/base/image-impl.c b/internal/cgen/base/image-impl.c index 5bff8eab..0ed466cb 100644 --- a/internal/cgen/base/image-impl.c +++ b/internal/cgen/base/image-impl.c @@ -21,6 +21,30 @@ const uint32_t wuffs_base__pixel_format__bits_per_channel[16] = { 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40, }; +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; + uint8_t* s = src.ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + wuffs_base__store_u32le(d + (0 * 4), + 0xFF000000 | (0x010101 * (uint32_t)s[0])); + + s += 1 * 1; + d += 4 * 1; + n -= (size_t)(1 * 1); + } + + return len; +} + static uint64_t // wuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette, @@ -83,6 +107,7 @@ wuffs_base__pixel_swizzler__copy_3_1(wuffs_base__slice_u8 dst, return len; } + static uint64_t // wuffs_base__pixel_swizzler__copy_4_1(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette, @@ -171,6 +196,27 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, wuffs_base__slice_u8 src) = NULL; switch (src_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (dst_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__BGR: + 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: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + case WUFFS_BASE__PIXEL_FORMAT__RGBX: + 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; + break; + default: + break; + } + break; + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: switch (dst_format.repr) { case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: diff --git a/internal/cgen/data.go b/internal/cgen/data.go index 7b9decb2..027135dc 100644 --- a/internal/cgen/data.go +++ b/internal/cgen/data.go @@ -26,13 +26,15 @@ 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__copy_3_1(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 \">=\", be" + - "cause 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}\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_4_1(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_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__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_s" + - "wizzler* 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__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 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__copy_3_1;\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__copy_4_1;\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__copy_3_1;\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__copy_4_1;\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__swizzle_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__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__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__copy_3_1(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__copy_4_1(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 10" + + "24) {\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_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__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_ba" + + "se__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_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 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__copy_3_1;\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__copy_4_1;\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__copy_3_1;\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__copy_4_1;\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__swizzle_interlea" + + "ved(\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" + "" const baseCorePrivateH = "" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index a440682b..69bdd08a 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -4240,6 +4240,7 @@ struct wuffs_wbmp__decoder__struct { bool f_seen_frame; bool f_seen_frame_config; uint64_t f_frame_config_io_position; + wuffs_base__pixel_swizzler f_swizzler; uint32_t p_decode_image_config[1]; uint32_t p_decode_frame_config[1]; @@ -4251,6 +4252,12 @@ struct wuffs_wbmp__decoder__struct { uint32_t v_i; uint32_t v_x32; } s_decode_image_config[1]; + struct { + uint32_t v_dst_x; + uint32_t v_dst_y; + uint8_t v_src[1]; + uint8_t v_c; + } s_decode_frame[1]; } private_data; #ifdef __cplusplus @@ -5800,6 +5807,30 @@ const uint32_t wuffs_base__pixel_format__bits_per_channel[16] = { 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40, }; +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; + uint8_t* s = src.ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + wuffs_base__store_u32le(d + (0 * 4), + 0xFF000000 | (0x010101 * (uint32_t)s[0])); + + s += 1 * 1; + d += 4 * 1; + n -= (size_t)(1 * 1); + } + + return len; +} + static uint64_t // wuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette, @@ -5862,6 +5893,7 @@ wuffs_base__pixel_swizzler__copy_3_1(wuffs_base__slice_u8 dst, return len; } + static uint64_t // wuffs_base__pixel_swizzler__copy_4_1(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette, @@ -5950,6 +5982,27 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, wuffs_base__slice_u8 src) = NULL; switch (src_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (dst_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__BGR: + 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: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + case WUFFS_BASE__PIXEL_FORMAT__RGBX: + 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; + break; + default: + break; + } + break; + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: switch (dst_format.repr) { case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: @@ -13305,15 +13358,44 @@ wuffs_wbmp__decoder__decode_frame(wuffs_wbmp__decoder* self, self->private_impl.active_coroutine = 0; wuffs_base__status status = wuffs_base__make_status(NULL); + wuffs_base__status v_status = wuffs_base__make_status(NULL); + uint32_t v_dst_x = 0; + uint32_t v_dst_y = 0; + wuffs_base__table_u8 v_tab = {0}; + wuffs_base__slice_u8 v_dst = {0}; + uint8_t v_src[1] = {0}; + uint8_t v_c = 0; + + uint8_t* iop_a_src = NULL; + uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + if (a_src) { + io0_a_src = a_src->data.ptr; + io1_a_src = io0_a_src + a_src->meta.ri; + iop_a_src = io1_a_src; + io2_a_src = io0_a_src + a_src->meta.wi; + } + uint32_t coro_susp_point = self->private_impl.p_decode_frame[0]; if (coro_susp_point) { + v_dst_x = self->private_data.s_decode_frame[0].v_dst_x; + v_dst_y = self->private_data.s_decode_frame[0].v_dst_y; + memcpy(v_src, self->private_data.s_decode_frame[0].v_src, sizeof(v_src)); + v_c = self->private_data.s_decode_frame[0].v_c; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; if (self->private_impl.f_call_sequence < 2) { + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); status = wuffs_wbmp__decoder__decode_frame_config(self, NULL, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } if (status.repr) { goto suspend; } @@ -13322,6 +13404,59 @@ wuffs_wbmp__decoder__decode_frame(wuffs_wbmp__decoder* self, status = wuffs_base__make_status(wuffs_base__note__end_of_data); goto ok; } + v_status = wuffs_base__pixel_swizzler__prepare( + &self->private_impl.f_swizzler, + wuffs_base__pixel_buffer__pixel_format(a_dst), + wuffs_base__pixel_buffer__palette(a_dst), + wuffs_base__utility__make_pixel_format(268435464), + wuffs_base__utility__empty_slice_u8(), a_blend); + if (!wuffs_base__status__is_ok(&v_status)) { + status = v_status; + if (wuffs_base__status__is_error(&status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(&status)) { + status = wuffs_base__make_status( + wuffs_base__error__cannot_return_a_suspension); + goto exit; + } + goto ok; + } + if (self->private_impl.f_width > 0) { + v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0); + while (v_dst_y < self->private_impl.f_height) { + v_dst = wuffs_base__table_u8__row(v_tab, v_dst_y); + v_dst_x = 0; + while (v_dst_x < self->private_impl.f_width) { + if ((v_dst_x & 7) == 0) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) { + status = + wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; + } + uint8_t t_0 = *iop_a_src++; + v_c = t_0; + } + } + if ((v_c & 128) == 0) { + v_src[0] = 0; + } else { + v_src[0] = 255; + } + v_c <<= 1; + wuffs_base__pixel_swizzler__swizzle_interleaved( + &self->private_impl.f_swizzler, v_dst, + wuffs_base__utility__empty_slice_u8(), + wuffs_base__make_slice_u8(v_src, 1)); + if (((uint64_t)(v_dst.len)) >= 4) { + v_dst = wuffs_base__slice_u8__subslice_i(v_dst, 4); + } + v_dst_x += 1; + } + v_dst_y += 1; + } + } self->private_impl.f_seen_frame = true; self->private_impl.f_call_sequence = 3; @@ -13337,9 +13472,17 @@ suspend: wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0; + self->private_data.s_decode_frame[0].v_dst_x = v_dst_x; + self->private_data.s_decode_frame[0].v_dst_y = v_dst_y; + memcpy(self->private_data.s_decode_frame[0].v_src, v_src, sizeof(v_src)); + self->private_data.s_decode_frame[0].v_c = v_c; goto exit; exit: + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + if (wuffs_base__status__is_error(&status)) { self->private_impl.magic = WUFFS_BASE__DISABLED; } diff --git a/std/wbmp/decode_wbmp.wuffs b/std/wbmp/decode_wbmp.wuffs index 1114b8d0..120d0aee 100644 --- a/std/wbmp/decode_wbmp.wuffs +++ b/std/wbmp/decode_wbmp.wuffs @@ -26,7 +26,8 @@ pub struct decoder? implements base.image_decoder( seen_frame_config : base.bool, frame_config_io_position : base.u64, - util : base.utility, + swizzler : base.pixel_swizzler, + util : base.utility, ) pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_reader) { @@ -126,6 +127,14 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_ } pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) { + var status : base.status + var dst_x : base.u32 + var dst_y : base.u32 + var tab : table base.u8 + var dst : slice base.u8 + var src : array[1] base.u8 + var c : base.u8 + if this.call_sequence < 2 { this.decode_frame_config?(dst: nullptr, src: args.src) } else if this.call_sequence == 2 { @@ -134,7 +143,53 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, return base."@end of data" } - // TODO. + // TODO: a Wuffs (not just C) name for the + // WUFFS_BASE__PIXEL_FORMAT__Y magic pixfmt constant. + status = this.swizzler.prepare!( + dst_pixfmt: args.dst.pixel_format(), + dst_palette: args.dst.palette(), + src_pixfmt: this.util.make_pixel_format(repr: 0x10000008), + src_palette: this.util.empty_slice_u8(), + blend: args.blend) + if not status.is_ok() { + return status + } + + // TODO: be more efficient than reading one byte at a time. + if this.width > 0 { + tab = args.dst.plane(p: 0) + while dst_y < this.height { + assert dst_y < 0xFFFFFFFF via "a < b: a < c; c <= b"(c: this.height) + dst = tab.row(y: dst_y) + dst_x = 0 + + while dst_x < this.width, + inv dst_y < 0xFFFFFFFF, + { + assert dst_x < 0xFFFFFFFF via "a < b: a < c; c <= b"(c: this.width) + + if (dst_x & 7) == 0 { + c = args.src.read_u8?() + } + if (c & 0x80) == 0 { + src[0] = 0x00 + } else { + src[0] = 0xFF + } + c ~mod<<= 1 + + this.swizzler.swizzle_interleaved!( + dst: dst, dst_palette: this.util.empty_slice_u8(), src: src[..]) + + if dst.length() >= 4 { + dst = dst[4 ..] + } + + dst_x += 1 + } + dst_y += 1 + } + } this.seen_frame = true this.call_sequence = 3 diff --git a/test/c/std/wbmp.c b/test/c/std/wbmp.c index 8946b294..7f2010fe 100644 --- a/test/c/std/wbmp.c +++ b/test/c/std/wbmp.c @@ -69,6 +69,18 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // ---------------- WBMP Tests +const char* test_wuffs_wbmp_decode_interface() { + CHECK_FOCUS(__func__); + wuffs_wbmp__decoder dec; + CHECK_STATUS("initialize", + wuffs_wbmp__decoder__initialize( + &dec, sizeof dec, WUFFS_VERSION, + WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); + return do_test__wuffs_base__image_decoder( + wuffs_wbmp__decoder__upcast_as__wuffs_base__image_decoder(&dec), + "test/data/muybridge-frame-000.wbmp", 0, SIZE_MAX, 30, 20, 0xFFFFFFFF); +} + const char* test_wuffs_wbmp_decode_image_config() { CHECK_FOCUS(__func__); wuffs_wbmp__decoder dec; @@ -125,6 +137,7 @@ const char* test_wuffs_wbmp_decode_image_config() { proc tests[] = { test_wuffs_wbmp_decode_image_config, // + test_wuffs_wbmp_decode_interface, // #ifdef WUFFS_MIMIC