Implement bmp.decoder.decode_frame

This commit is contained in:
Nigel Tao committed 2020-02-07 16:27:04 +11:00
1 parent 8378d9f3b4
commit e6cc2fe8f0
6 files changed
+613 -77

No files matched your search

+15
View File
@@ -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,
+64
View File
@@ -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;
+7 -3
View File
@@ -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 = "" +
+318 -42
View File
@@ -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:
+208 -31
View File
@@ -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
}
+1 -1
View File
@@ -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() {