From e6cc2fe8f05f863ad4adf73f1b79ff6a8deac842 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 6 Feb 2020 14:36:29 +1100 Subject: [PATCH] Implement bmp.decoder.decode_frame --- example/imageviewer/imageviewer.c | 15 ++ internal/cgen/base/image-impl.c | 64 +++++ internal/cgen/data.go | 10 +- release/c/wuffs-unsupported-snapshot.c | 360 ++++++++++++++++++++++--- std/bmp/decode_bmp.wuffs | 239 +++++++++++++--- test/c/std/bmp.c | 2 +- 6 files changed, 613 insertions(+), 77 deletions(-) diff --git a/example/imageviewer/imageviewer.c b/example/imageviewer/imageviewer.c index cc8528f4..8cc25c0f 100644 --- a/example/imageviewer/imageviewer.c +++ b/example/imageviewer/imageviewer.c @@ -53,6 +53,7 @@ The Escape key quits. // code simply isn't compiled. #define WUFFS_CONFIG__MODULES #define WUFFS_CONFIG__MODULE__BASE +#define WUFFS_CONFIG__MODULE__BMP #define WUFFS_CONFIG__MODULE__GIF #define WUFFS_CONFIG__MODULE__LZW #define WUFFS_CONFIG__MODULE__WBMP @@ -90,6 +91,7 @@ wuffs_base__image_decoder* g_image_decoder = NULL; uint32_t g_background_color_index = 0; union { + wuffs_bmp__decoder bmp; wuffs_gif__decoder gif; wuffs_wbmp__decoder wbmp; } g_potential_decoders; @@ -140,6 +142,19 @@ bool load_image_type() { &g_potential_decoders.wbmp); break; + case 'B': + status = wuffs_bmp__decoder__initialize( + &g_potential_decoders.bmp, sizeof g_potential_decoders.bmp, + 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_bmp__decoder__upcast_as__wuffs_base__image_decoder( + &g_potential_decoders.bmp); + 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 280f02a7..6c77b336 100644 --- a/internal/cgen/base/image-impl.c +++ b/internal/cgen/base/image-impl.c @@ -489,6 +489,31 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( return len; } +static uint64_t // +wuffs_base__pixel_swizzler__xxxx__xxx(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 src_len3 = src.len / 3; + size_t len = dst_len4 < src_len3 ? dst_len4 : src_len3; + 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 | wuffs_base__load_u24le(s + (0 * 3))); + + s += 3 * 1; + d += 4 * 1; + n -= 1; + } + + return len; +} + static uint64_t // wuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette, @@ -680,6 +705,40 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary( return NULL; } +static wuffs_base__pixel_swizzler__func // +wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_format, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src_palette, + wuffs_base__pixel_blend blend) { + switch (dst_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: + // TODO. + break; + + 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: + return wuffs_base__pixel_swizzler__xxxx__xxx; + + 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: + // TODO. + break; + } + return NULL; +} + +// -------- + wuffs_base__status // wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, wuffs_base__pixel_format dst_format, @@ -705,6 +764,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary( p, dst_format, dst_palette, src_palette, blend); break; + + case WUFFS_BASE__PIXEL_FORMAT__BGR: + func = wuffs_base__pixel_swizzler__prepare__bgr( + p, dst_format, dst_palette, src_palette, blend); + break; } p->private_impl.func = func; diff --git a/internal/cgen/data.go b/internal/cgen/data.go index 7cbb5a38..6d7f8619 100644 --- a/internal/cgen/data.go +++ b/internal/cgen/data.go @@ -42,7 +42,8 @@ const baseImageImplC = "" + "1);\n }\n uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__store_u24le(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__store_u24le(d + (3 * 4), s3);\n }\n\n s += 1 * loop_unroll_count;\n d += 3 * loop_unroll_count;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_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 -= 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 u" + "int8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u32le(\n d + (1 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u32le(\n d + (2 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_base__store_u32le(\n d + (3 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += 1 * loop_unroll_count;\n d += 4 * loop_unroll_count;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 4 * 1;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(\n wuffs_bas" + "e__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 const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u32le(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__store_u32le(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__store_u32le(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__store_u32le(d + (3 * 4), s3);\n }\n\n s += 1 * loop_unroll_count;\n d += 4 * loop_unroll_count;" + - "\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_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 -= 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 -= 1;\n }\n\n return len;\n}\n\n" + + "\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_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 -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__xxx(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 src_len3 = src.len / 3;\n size_t len = dst_len4 < src_len3 ? dst_len4 : src_len3;\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 | wuffs_base__load_u24le(s + (0 * 3)));\n\n s += 3 * 1;\n d += 4 * 1;\n n -= 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 -= 1;\n }\n\n return len;\n}\n\n" + "" + "// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__squash_bgr_565_888(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 uint32_t argb = wuffs_base__load_u32le(s);\n uint32_t b5 = 0x1F & (argb >> (8 - 5));\n uint32_t g6 = 0x3F & (argb >> (16 - 6));\n uint32_t r5 = 0x1F & (argb >> (24 - 5));\n wuffs_base__store_u32le(d, (b5 << 0) | (g6 << 5) | (r5 << 11));\n s += 4;\n d += 4;\n }\n return len4 * 4;\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" + @@ -51,8 +52,11 @@ const baseImageImplC = "" + "fs_base__pixel_swizzler__xxxx__y;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\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 return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n if (wuffs_base__pixel_swizzler__squash_bgr_565_888(dst_palette,\n src_palette) != 1024) {\n " + " return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xx__index__src;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n }\n return NULL;\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 return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__sr" + "c;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n if (wuffs_base__pixel_swizzler__swap_rgbx_bgrx(dst_palette,\n src_palette) != 1024) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over;\n }\n return NULL;\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 return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__P" + - "IXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n }\n return NULL;\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 wuffs_base__pixel_swizzler__func func = NULL;\n\n switch (src_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n func = wuffs_base__pixel_swizzler__prepare__y(p, dst_format, dst_palette,\n" + - " src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n p, dst_format, dst_palette, src_palette, blend);\n break;\n }\n\n p->private_impl.func = func;\n return wuffs_base__make_status(\n func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_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" + + "IXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__xxxx__index__src;\n case WUFFS_BASE__PIXEL_BLEND__SRC_OVER:\n return wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over;\n }\n return NULL;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n // TODO.\n break;\n\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_PREMU" + + "L:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__pixel_swizzler__xxxx__xxx;\n\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 // TODO.\n break;\n }\n return NULL;\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 wuffs_base__pixel_swizzler__func func = NULL;\n\n switch (src_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n func = wuffs_base__pixel_swizzler__prepare__y(p, dst_format, dst_palette,\n src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n p, dst_format, dst_" + + "palette, src_palette, blend);\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n func = wuffs_base__pixel_swizzler__prepare__bgr(\n p, dst_format, dst_palette, src_palette, blend);\n break;\n }\n\n p->private_impl.func = func;\n return wuffs_base__make_status(\n func ? NULL : wuffs_base__error__unsupported_pixel_swizzler_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" + "" const baseCorePrivateH = "" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 79df2f03..ca763161 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -3248,10 +3248,21 @@ struct wuffs_bmp__decoder__struct { uint32_t f_width; uint32_t f_height; uint8_t f_call_sequence; - uint8_t f_bits_per_pixel; bool f_top_down; + uint8_t f_bits_per_pixel; + uint32_t f_pad_per_row; + uint64_t f_bytes_per_row; + uint64_t f_bytes_total; + wuffs_base__pixel_format f_pixfmt; uint32_t f_padding; uint64_t f_frame_config_io_position; + uint32_t f_dst_x; + uint32_t f_dst_y; + uint32_t f_dst_y_end; + uint32_t f_dst_y_inc; + uint8_t f_stash[4]; + uint8_t f_num_stashed; + uint8_t f_pending_pad; wuffs_base__pixel_swizzler f_swizzler; uint32_t p_decode_image_config[1]; @@ -3266,11 +3277,10 @@ struct wuffs_bmp__decoder__struct { uint64_t scratch; } s_decode_image_config[1]; struct { + uint64_t v_bytes_remaining; uint64_t scratch; } s_decode_frame[1]; struct { - uint64_t v_bytes_per_row; - uint32_t v_y; uint64_t scratch; } s_skip_frame[1]; } private_data; @@ -6965,6 +6975,31 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( return len; } +static uint64_t // +wuffs_base__pixel_swizzler__xxxx__xxx(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 src_len3 = src.len / 3; + size_t len = dst_len4 < src_len3 ? dst_len4 : src_len3; + 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 | wuffs_base__load_u24le(s + (0 * 3))); + + s += 3 * 1; + d += 4 * 1; + n -= 1; + } + + return len; +} + static uint64_t // wuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst, wuffs_base__slice_u8 dst_palette, @@ -7156,6 +7191,40 @@ wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary( return NULL; } +static wuffs_base__pixel_swizzler__func // +wuffs_base__pixel_swizzler__prepare__bgr(wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_format, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src_palette, + wuffs_base__pixel_blend blend) { + switch (dst_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: + // TODO. + break; + + 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: + return wuffs_base__pixel_swizzler__xxxx__xxx; + + 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: + // TODO. + break; + } + return NULL; +} + +// -------- + wuffs_base__status // wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, wuffs_base__pixel_format dst_format, @@ -7181,6 +7250,11 @@ wuffs_base__pixel_swizzler__prepare(wuffs_base__pixel_swizzler* p, func = wuffs_base__pixel_swizzler__prepare__indexed__bgra_binary( p, dst_format, dst_palette, src_palette, blend); break; + + case WUFFS_BASE__PIXEL_FORMAT__BGR: + func = wuffs_base__pixel_swizzler__prepare__bgr( + p, dst_format, dst_palette, src_palette, blend); + break; } p->private_impl.func = func; @@ -7372,8 +7446,8 @@ wuffs_adler32__hasher__update_u32(wuffs_adler32__hasher* self, const char* wuffs_bmp__error__bad_header = "#bmp: bad header"; const char* wuffs_bmp__error__unsupported_bmp_file = "#bmp: unsupported BMP file"; -const char* wuffs_bmp__error__internal_error_inconsistent_bpp = - "#bmp: internal error: inconsistent bpp"; +const char* wuffs_bmp__error__internal_error_inconsistent_swizzle_count = + "#bmp: internal error: inconsistent swizzle count"; // ---------------- Private Consts @@ -7381,6 +7455,11 @@ const char* wuffs_bmp__error__internal_error_inconsistent_bpp = // ---------------- Private Function Prototypes +static wuffs_base__status // +wuffs_bmp__decoder__swizzle(wuffs_bmp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__slice_u8 a_src); + static wuffs_base__status // wuffs_bmp__decoder__skip_frame(wuffs_bmp__decoder* self, wuffs_base__io_buffer* a_src); @@ -7509,6 +7588,8 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, uint32_t v_magic = 0; uint32_t v_bitmapInfoLen = 0; + uint32_t v_width = 0; + uint32_t v_height = 0; uint32_t v_planes = 0; uint32_t v_bits_per_pixel = 0; uint32_t v_compression = 0; @@ -7687,12 +7768,13 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, *scratch |= ((uint64_t)(num_bits_3)) << 56; } } - self->private_impl.f_width = t_3; + v_width = t_3; } - if (self->private_impl.f_width >= 2147483648) { + if (v_width >= 2147483648) { status = wuffs_base__make_status(wuffs_bmp__error__bad_header); goto exit; } + self->private_impl.f_width = v_width; { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); uint32_t t_4; @@ -7722,14 +7804,17 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, *scratch |= ((uint64_t)(num_bits_4)) << 56; } } - self->private_impl.f_height = t_4; + v_height = t_4; } - if (self->private_impl.f_height == 2147483648) { + if (v_height == 2147483648) { status = wuffs_base__make_status(wuffs_bmp__error__bad_header); goto exit; - } else if (self->private_impl.f_height > 2147483648) { - self->private_impl.f_height = (0 - self->private_impl.f_height); + } else if (v_height >= 2147483648) { + self->private_impl.f_height = + ((0 - self->private_impl.f_height) & 2147483647); self->private_impl.f_top_down = true; + } else { + self->private_impl.f_height = v_height; } { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); @@ -7797,11 +7882,20 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, } v_bits_per_pixel = t_6; } - if (v_bits_per_pixel != 24) { + if (v_bits_per_pixel == 24) { + self->private_impl.f_bits_per_pixel = 24; + self->private_impl.f_bytes_per_row = + ((((((uint64_t)(self->private_impl.f_width)) * 3) + 3) >> 2) << 2); + self->private_impl.f_pad_per_row = (self->private_impl.f_width & 3); + self->private_impl.f_pixfmt = + wuffs_base__utility__make_pixel_format(1073744008); + } else { status = wuffs_base__make_status(wuffs_bmp__error__unsupported_bmp_file); goto exit; } - self->private_impl.f_bits_per_pixel = ((uint8_t)((v_bits_per_pixel & 255))); + self->private_impl.f_bytes_total = + (self->private_impl.f_bytes_per_row * + ((uint64_t)(self->private_impl.f_height))); { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); uint32_t t_7; @@ -8034,6 +8128,11 @@ wuffs_bmp__decoder__decode_frame(wuffs_bmp__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); + uint64_t v_bytes_remaining = 0; + uint64_t v_n = 0; + wuffs_base__slice_u8 v_src = {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; @@ -8047,6 +8146,7 @@ wuffs_bmp__decoder__decode_frame(wuffs_bmp__decoder* self, uint32_t coro_susp_point = self->private_impl.p_decode_frame[0]; if (coro_susp_point) { + v_bytes_remaining = self->private_data.s_decode_frame[0].v_bytes_remaining; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8079,6 +8179,63 @@ wuffs_bmp__decoder__decode_frame(wuffs_bmp__decoder* self, goto suspend; } iop_a_src += self->private_data.s_decode_frame[0].scratch; + if ((self->private_impl.f_width > 0) && (self->private_impl.f_height > 0)) { + self->private_impl.f_dst_x = 0; + if (self->private_impl.f_top_down) { + self->private_impl.f_dst_y = 0; + self->private_impl.f_dst_y_end = self->private_impl.f_height; + self->private_impl.f_dst_y_inc = 1; + } else { + self->private_impl.f_dst_y = (self->private_impl.f_height - 1); + self->private_impl.f_dst_y_end = 4294967295; + self->private_impl.f_dst_y_inc = 4294967295; + } + 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), self->private_impl.f_pixfmt, + 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; + } + v_bytes_remaining = self->private_impl.f_bytes_total; + while (true) { + v_n = ((uint64_t)(io2_a_src - iop_a_src)); + if (v_bytes_remaining >= v_n) { + v_bytes_remaining -= v_n; + } else { + v_n = v_bytes_remaining; + v_bytes_remaining = 0; + } + v_src = wuffs_base__io_reader__take(&iop_a_src, io2_a_src, v_n); + v_status = wuffs_bmp__decoder__swizzle(self, a_dst, v_src); + if (wuffs_base__status__is_ok(&v_status)) { + goto label_0_break; + } else if (wuffs_base__status__is_suspension(&v_status)) { + status = v_status; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); + } else { + 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; + } + } + label_0_break:; + } self->private_impl.f_call_sequence = 3; goto ok; @@ -8093,6 +8250,7 @@ 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_bytes_remaining = v_bytes_remaining; goto exit; exit: @@ -8106,6 +8264,142 @@ exit: return status; } +// -------- func bmp.decoder.swizzle + +static wuffs_base__status // +wuffs_bmp__decoder__swizzle(wuffs_bmp__decoder* self, + wuffs_base__pixel_buffer* a_dst, + wuffs_base__slice_u8 a_src) { + wuffs_base__pixel_format v_dst_pixfmt = {0}; + uint32_t v_dst_bits_per_pixel = 0; + uint64_t v_dst_bytes_per_pixel = 0; + uint64_t v_dst_bytes_per_row = 0; + uint8_t v_src_bytes_per_pixel = 0; + wuffs_base__table_u8 v_tab = {0}; + wuffs_base__slice_u8 v_dst = {0}; + uint64_t v_i = 0; + uint64_t v_n = 0; + + v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); + v_dst_bits_per_pixel = + wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); + if ((v_dst_bits_per_pixel > 512) || ((v_dst_bits_per_pixel & 7) != 0)) { + return wuffs_base__make_status(wuffs_base__error__unsupported_option); + } + v_dst_bytes_per_pixel = ((uint64_t)((v_dst_bits_per_pixel / 8))); + v_dst_bytes_per_row = + (((uint64_t)(self->private_impl.f_width)) * v_dst_bytes_per_pixel); + v_src_bytes_per_pixel = + ((uint8_t)((self->private_impl.f_bits_per_pixel / 8))); + v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0); + while (self->private_impl.f_pending_pad > 0) { + if (((uint64_t)(a_src.len)) <= 0) { + return wuffs_base__make_status(wuffs_base__suspension__short_read); + } +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + self->private_impl.f_pending_pad -= 1; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + a_src = wuffs_base__slice_u8__subslice_i(a_src, 1); + } + if (self->private_impl.f_num_stashed != 0) { + while (self->private_impl.f_num_stashed < v_src_bytes_per_pixel) { + if (((uint64_t)(a_src.len)) <= 0) { + return wuffs_base__make_status(wuffs_base__suspension__short_read); + } + self->private_impl.f_stash[self->private_impl.f_num_stashed] = + a_src.ptr[0]; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + self->private_impl.f_num_stashed += 1; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + a_src = wuffs_base__slice_u8__subslice_i(a_src, 1); + } + v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y); + if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); + } + v_i = (((uint64_t)(self->private_impl.f_dst_x)) * v_dst_bytes_per_pixel); + if (v_i < ((uint64_t)(v_dst.len))) { + wuffs_base__pixel_swizzler__swizzle_interleaved( + &self->private_impl.f_swizzler, + wuffs_base__slice_u8__subslice_i(v_dst, v_i), + wuffs_base__utility__empty_slice_u8(), + wuffs_base__slice_u8__subslice_j( + wuffs_base__make_slice_u8(self->private_impl.f_stash, 4), + self->private_impl.f_num_stashed)); + wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, 1); + } + self->private_impl.f_num_stashed = 0; + } + while (true) { + if (self->private_impl.f_dst_x == self->private_impl.f_width) { + self->private_impl.f_dst_x = 0; + self->private_impl.f_dst_y += self->private_impl.f_dst_y_inc; + if (self->private_impl.f_pad_per_row != 0) { + v_n = ((uint64_t)(self->private_impl.f_pad_per_row)); + if (v_n <= ((uint64_t)(a_src.len))) { + a_src = wuffs_base__slice_u8__subslice_i(a_src, v_n); + } else { + self->private_impl.f_pending_pad = + ((uint8_t)(((v_n - ((uint64_t)(a_src.len))) & 3))); + return wuffs_base__make_status(wuffs_base__suspension__short_read); + } + } + } + if (self->private_impl.f_dst_y == self->private_impl.f_dst_y_end) { + goto label_0_break; + } + v_dst = wuffs_base__table_u8__row(v_tab, self->private_impl.f_dst_y); + if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); + } + v_i = (((uint64_t)(self->private_impl.f_dst_x)) * v_dst_bytes_per_pixel); + if (v_i < ((uint64_t)(v_dst.len))) { + v_n = wuffs_base__pixel_swizzler__swizzle_interleaved( + &self->private_impl.f_swizzler, + wuffs_base__slice_u8__subslice_i(v_dst, v_i), + wuffs_base__utility__empty_slice_u8(), a_src); + wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, + ((uint32_t)((v_n & 4294967295)))); + v_n = ((v_n & 4294967295) * ((uint64_t)(v_src_bytes_per_pixel))); + if (v_n <= ((uint64_t)(a_src.len))) { + a_src = wuffs_base__slice_u8__subslice_i(a_src, v_n); + } else { + return wuffs_base__make_status( + wuffs_bmp__error__internal_error_inconsistent_swizzle_count); + } + } + if (self->private_impl.f_dst_x < self->private_impl.f_width) { + while ((self->private_impl.f_num_stashed < v_src_bytes_per_pixel) && + (((uint64_t)(a_src.len)) > 0)) { + self->private_impl.f_stash[self->private_impl.f_num_stashed] = + a_src.ptr[0]; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + self->private_impl.f_num_stashed += 1; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + a_src = wuffs_base__slice_u8__subslice_i(a_src, 1); + } + return wuffs_base__make_status(wuffs_base__suspension__short_read); + } + } +label_0_break:; + return wuffs_base__make_status(NULL); +} + // -------- func bmp.decoder.skip_frame static wuffs_base__status // @@ -8113,9 +8407,6 @@ wuffs_bmp__decoder__skip_frame(wuffs_bmp__decoder* self, wuffs_base__io_buffer* a_src) { wuffs_base__status status = wuffs_base__make_status(NULL); - uint64_t v_bytes_per_row = 0; - uint32_t v_y = 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; @@ -8129,8 +8420,6 @@ wuffs_bmp__decoder__skip_frame(wuffs_bmp__decoder* self, uint32_t coro_susp_point = self->private_impl.p_skip_frame[0]; if (coro_susp_point) { - v_bytes_per_row = self->private_data.s_skip_frame[0].v_bytes_per_row; - v_y = self->private_data.s_skip_frame[0].v_y; } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -8146,29 +8435,18 @@ wuffs_bmp__decoder__skip_frame(wuffs_bmp__decoder* self, goto suspend; } iop_a_src += self->private_data.s_skip_frame[0].scratch; - if (self->private_impl.f_bits_per_pixel == 24) { - v_bytes_per_row = - ((((((uint64_t)(self->private_impl.f_width)) * 3) + 3) >> 2) << 2); - } else { - status = wuffs_base__make_status( - wuffs_bmp__error__internal_error_inconsistent_bpp); - goto exit; - } - v_y = self->private_impl.f_height; - while (v_y > 0) { - v_y -= 1; - self->private_data.s_skip_frame[0].scratch = v_bytes_per_row; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); - if (self->private_data.s_skip_frame[0].scratch > - ((uint64_t)(io2_a_src - iop_a_src))) { - self->private_data.s_skip_frame[0].scratch -= - ((uint64_t)(io2_a_src - iop_a_src)); - iop_a_src = io2_a_src; - status = wuffs_base__make_status(wuffs_base__suspension__short_read); - goto suspend; - } - iop_a_src += self->private_data.s_skip_frame[0].scratch; + self->private_data.s_skip_frame[0].scratch = + self->private_impl.f_bytes_total; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + if (self->private_data.s_skip_frame[0].scratch > + ((uint64_t)(io2_a_src - iop_a_src))) { + self->private_data.s_skip_frame[0].scratch -= + ((uint64_t)(io2_a_src - iop_a_src)); + iop_a_src = io2_a_src; + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + goto suspend; } + iop_a_src += self->private_data.s_skip_frame[0].scratch; self->private_impl.f_call_sequence = 3; goto ok; @@ -8181,8 +8459,6 @@ wuffs_bmp__decoder__skip_frame(wuffs_bmp__decoder* self, suspend: self->private_impl.p_skip_frame[0] = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; - self->private_data.s_skip_frame[0].v_bytes_per_row = v_bytes_per_row; - self->private_data.s_skip_frame[0].v_y = v_y; goto exit; exit: diff --git a/std/bmp/decode_bmp.wuffs b/std/bmp/decode_bmp.wuffs index 37fd806e..129f3948 100644 --- a/std/bmp/decode_bmp.wuffs +++ b/std/bmp/decode_bmp.wuffs @@ -15,23 +15,36 @@ pub status "#bad header" pub status "#unsupported BMP file" -pri status "#internal error: inconsistent bpp" +pri status "#internal error: inconsistent swizzle count" pub const decoder_workbuf_len_max_incl_worst_case base.u64 = 0 pub struct decoder? implements base.image_decoder( - width : base.u32, - height : base.u32, + width : base.u32[..= 0x7FFFFFFF], + height : base.u32[..= 0x7FFFFFFF], call_sequence : base.u8, - bits_per_pixel : base.u8, top_down : base.bool, + bits_per_pixel : base.u8[..= 32], + pad_per_row : base.u32[..= 3], + bytes_per_row : base.u64[..= 0x00000001FFFFFFFC], // 4 * 0x7FFFFFFF + bytes_total : base.u64[..= 0xFFFFFFFC00000004], // 4 * 0x7FFFFFFF * 0x7FFFFFFF + pixfmt : base.pixel_format, padding : base.u32, frame_config_io_position : base.u64, + dst_x : base.u32, + dst_y : base.u32, + dst_y_end : base.u32, + dst_y_inc : base.u32, + + stash : array[4] base.u8, + num_stashed : base.u8[..= 4], + pending_pad : base.u8[..= 3], + swizzler : base.pixel_swizzler, util : base.utility, ) @@ -39,6 +52,8 @@ pub struct decoder? implements base.image_decoder( pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_reader) { var magic : base.u32 var bitmapInfoLen : base.u32 + var width : base.u32 + var height : base.u32 var planes : base.u32 var bits_per_pixel : base.u32 var compression : base.u32 @@ -75,17 +90,22 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_ } this.padding -= bitmapInfoLen - this.width = args.src.read_u32le?() - if this.width >= 0x80000000 { + width = args.src.read_u32le?() + if width >= 0x80000000 { return "#bad header" } + this.width = width - this.height = args.src.read_u32le?() - if this.height == 0x80000000 { + height = args.src.read_u32le?() + if height == 0x80000000 { return "#bad header" - } else if this.height > 0x80000000 { - this.height = 0 ~mod- this.height + } else if height >= 0x80000000 { + // The &0x7FFFFFFF is redundant, but proves to the compiler that the + // result is within this.height's refined bounds. + this.height = (0 ~mod- this.height) & 0x7FFFFFFF this.top_down = true + } else { + this.height = height } planes = args.src.read_u16le_as_u32?() @@ -94,11 +114,20 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_ } bits_per_pixel = args.src.read_u16le_as_u32?() - if bits_per_pixel <> 24 { + if bits_per_pixel == 24 { + this.bits_per_pixel = 24 + // 3 bytes per pixel, but row lengths are rounded up to multiples of 4. + // The "((x + 3) >> 2) << 2" dance rounds x up. + this.bytes_per_row = ((((this.width as base.u64) * 3) + 3) >> 2) << 2 + this.pad_per_row = this.width & 3 + // TODO: a Wuffs (not just C) name for the + // WUFFS_BASE__PIXEL_FORMAT__BGR magic pixfmt constant. + this.pixfmt = this.util.make_pixel_format(repr: 0x40000888) + } else { // TODO: support 8bpp, 32bpp, possibly more. return "#unsupported BMP file" } - this.bits_per_pixel = (bits_per_pixel & 0xFF) as base.u8 + this.bytes_total = this.bytes_per_row * (this.height as base.u64) compression = args.src.read_u32le?() if compression <> 0 { @@ -116,7 +145,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_ // TODO: a Wuffs (not just C) name for the // WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL magic pixfmt constant. args.dst.set!( - pixfmt: 0x45008888, + pixfmt: 0x45008888, // TODO: this.pixfmt instead? pixsub: 0, width: this.width, height: this.height, @@ -160,6 +189,11 @@ 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 bytes_remaining : base.u64 + var n : base.u64 + var src : slice base.u8 + if this.call_sequence < 2 { this.decode_frame_config?(dst: nullptr, src: args.src) } else if this.call_sequence == 2 { @@ -170,30 +204,173 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, args.src.skip32?(n: this.padding) - // TODO. + if (this.width > 0) and (this.height > 0) { + this.dst_x = 0 + if this.top_down { + this.dst_y = 0 + this.dst_y_end = this.height + this.dst_y_inc = 1 + } else { + this.dst_y = this.height ~mod- 1 + this.dst_y_end = 0xFFFFFFFF // -1 as a base.u32. + this.dst_y_inc = 0xFFFFFFFF // -1 as a base.u32. + } + + status = this.swizzler.prepare!( + dst_pixfmt: args.dst.pixel_format(), + dst_palette: args.dst.palette(), + src_pixfmt: this.pixfmt, + src_palette: this.util.empty_slice_u8(), + blend: args.blend) + if not status.is_ok() { + return status + } + + bytes_remaining = this.bytes_total + while true { + n = args.src.available() + if bytes_remaining >= n { + bytes_remaining -= n + } else { + n = bytes_remaining + bytes_remaining = 0 + } + src = args.src.take!(n: n) + status = this.swizzle!(dst: args.dst, src: src) + if status.is_ok() { + break + } else if status.is_suspension() { + yield? status + } else { + return status + } + } + } this.call_sequence = 3 } +pri func decoder.swizzle!(dst: ptr base.pixel_buffer, src: slice base.u8) base.status { + var dst_pixfmt : base.pixel_format + var dst_bits_per_pixel : base.u32 + var dst_bytes_per_pixel : base.u64[..= 64] + var dst_bytes_per_row : base.u64 + var src_bytes_per_pixel : base.u8[..= 4] + var tab : table base.u8 + var dst : slice base.u8 + var i : base.u64 + var n : base.u64 + + // TODO: the dst_pixfmt variable shouldn't be necessary. We should be able + // to chain the two calls: "args.dst.pixel_format().bits_per_pixel()". + dst_pixfmt = args.dst.pixel_format() + dst_bits_per_pixel = dst_pixfmt.bits_per_pixel() + if (dst_bits_per_pixel > 512) or ((dst_bits_per_pixel & 7) <> 0) { + return base."#unsupported option" + } + dst_bytes_per_pixel = (dst_bits_per_pixel / 8) as base.u64 + dst_bytes_per_row = (this.width as base.u64) * dst_bytes_per_pixel + src_bytes_per_pixel = (this.bits_per_pixel / 8) as base.u8 + tab = args.dst.plane(p: 0) + + // Handle the case where the I/O suspension occurred in the middle of the + // end-of-row padding. + while this.pending_pad > 0 { + if args.src.length() <= 0 { + return base."$short read" + } + this.pending_pad -= 1 + args.src = args.src[1 ..] + } + + // Handle the case where the I/O suspension occurred in the middle of a + // source pixel. + if this.num_stashed <> 0 { + while this.num_stashed < src_bytes_per_pixel { + assert this.num_stashed < 4 via "a < b: a < c; c <= b"(c: src_bytes_per_pixel) + if args.src.length() <= 0 { + return base."$short read" + } + this.stash[this.num_stashed] = args.src[0] + this.num_stashed += 1 + args.src = args.src[1 ..] + } + + // Write the single pixel. + dst = tab.row(y: this.dst_y) + if dst_bytes_per_row < dst.length() { + dst = dst[.. dst_bytes_per_row] + } + i = (this.dst_x as base.u64) * dst_bytes_per_pixel + if i < dst.length() { + this.swizzler.swizzle_interleaved!( + dst: dst[i ..], + dst_palette: this.util.empty_slice_u8(), + src: this.stash[.. this.num_stashed]) + this.dst_x ~sat+= 1 + } + + this.num_stashed = 0 + } + + while true { + if this.dst_x == this.width { + this.dst_x = 0 + this.dst_y ~mod+= this.dst_y_inc + + if this.pad_per_row <> 0 { + n = this.pad_per_row as base.u64 + if n <= args.src.length() { + args.src = args.src[n ..] + } else { + this.pending_pad = ((n - args.src.length()) & 3) as base.u8 + return base."$short read" + } + } + } + + if this.dst_y == this.dst_y_end { + break + } + + dst = tab.row(y: this.dst_y) + if dst_bytes_per_row < dst.length() { + dst = dst[.. dst_bytes_per_row] + } + i = (this.dst_x as base.u64) * dst_bytes_per_pixel + if i < dst.length() { + n = this.swizzler.swizzle_interleaved!( + dst: dst[i ..], + dst_palette: this.util.empty_slice_u8(), + src: args.src) + this.dst_x ~sat+= (n & 0xFFFFFFFF) as base.u32 + n = (n & 0xFFFFFFFF) * (src_bytes_per_pixel as base.u64) + if n <= args.src.length() { + args.src = args.src[n ..] + } else { + return "#internal error: inconsistent swizzle count" + } + } + + // Suspend if we didn't complete the row, potentially in the middle of + // a source pixel. + if this.dst_x < this.width { + while (this.num_stashed < src_bytes_per_pixel) and (args.src.length() > 0) { + assert this.num_stashed < 4 via "a < b: a < c; c <= b"(c: src_bytes_per_pixel) + this.stash[this.num_stashed] = args.src[0] + this.num_stashed += 1 + args.src = args.src[1 ..] + } + return base."$short read" + } + } + + return ok +} + pri func decoder.skip_frame?(src: base.io_reader) { - var bytes_per_row : base.u64 - var y : base.u32 - args.src.skip32?(n: this.padding) - - if this.bits_per_pixel == 24 { - // 3 bytes per pixel. We add 3 and shift twice to round up to a - // multiple of 4. - bytes_per_row = ((((this.width as base.u64) * 3) + 3) >> 2) << 2 - } else { - return "#internal error: inconsistent bpp" - } - - y = this.height - while y > 0 { - y -= 1 - args.src.skip?(n: bytes_per_row) - } + args.src.skip?(n: this.bytes_total) this.call_sequence = 3 } diff --git a/test/c/std/bmp.c b/test/c/std/bmp.c index 96b86c36..c482bf57 100644 --- a/test/c/std/bmp.c +++ b/test/c/std/bmp.c @@ -78,7 +78,7 @@ const char* test_wuffs_bmp_decode_interface() { WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED)); return do_test__wuffs_base__image_decoder( wuffs_bmp__decoder__upcast_as__wuffs_base__image_decoder(&dec), - "test/data/hippopotamus.bmp", 0, SIZE_MAX, 36, 28, 0x00000000); + "test/data/hippopotamus.bmp", 0, SIZE_MAX, 36, 28, 0xFFF5F5F5); } const char* test_wuffs_bmp_decode_frame_config() {