mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
Add more pixel formats to set_color_u32_at
This commit is contained in:
1 parent
9a1b8def46
commit
d585f9b902
5 files changed
+231
-26
No files matched your search
@@ -175,6 +175,18 @@ wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
|
||||
// Common formats above. Rarer formats below.
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y:
|
||||
wuffs_base__store_u8__no_bounds_check(
|
||||
row + ((size_t)x), wuffs_base__color_u32_argb_premul__as_gray(color));
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
|
||||
wuffs_base__store_u8__no_bounds_check(
|
||||
row + ((size_t)x), wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__pixel_buffer__palette(pb),
|
||||
pb->pixcfg.private_impl.pixfmt, color));
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {
|
||||
uint32_t b5 = 0x1F & (color >> (8 - 5));
|
||||
uint32_t g6 = 0x3F & (color >> (16 - 6));
|
||||
@@ -218,6 +230,68 @@ wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
|
||||
// --------
|
||||
|
||||
uint8_t //
|
||||
wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__slice_u8 palette_slice,
|
||||
wuffs_base__pixel_format palette_format,
|
||||
wuffs_base__color_u32_argb_premul c) {
|
||||
size_t n = palette_slice.len / 4;
|
||||
if (n > 256) {
|
||||
n = 256;
|
||||
}
|
||||
size_t best_index = 0;
|
||||
uint64_t best_score = 0xFFFFFFFFFFFFFFFF;
|
||||
|
||||
// Work in 16-bit color.
|
||||
uint32_t ca = 0x101 * (0xFF & (c >> 24));
|
||||
uint32_t cr = 0x101 * (0xFF & (c >> 16));
|
||||
uint32_t cg = 0x101 * (0xFF & (c >> 8));
|
||||
uint32_t cb = 0x101 * (0xFF & (c >> 0));
|
||||
|
||||
switch (palette_format.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
|
||||
bool nonpremul = palette_format.repr ==
|
||||
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;
|
||||
|
||||
size_t i;
|
||||
for (i = 0; i < n; i++) {
|
||||
// Work in 16-bit color.
|
||||
uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]));
|
||||
uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));
|
||||
uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));
|
||||
uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));
|
||||
|
||||
// Convert to premultiplied alpha.
|
||||
if (nonpremul && (pa != 0xFFFF)) {
|
||||
pb = (pb * pa) / 0xFFFF;
|
||||
pg = (pg * pa) / 0xFFFF;
|
||||
pr = (pr * pa) / 0xFFFF;
|
||||
}
|
||||
|
||||
// These deltas are conceptually int32_t (signed) but after squaring,
|
||||
// it's equivalent to work in uint32_t (unsigned).
|
||||
pb -= cb;
|
||||
pg -= cg;
|
||||
pr -= cr;
|
||||
pa -= ca;
|
||||
uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +
|
||||
((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));
|
||||
if (best_score > score) {
|
||||
best_score = score;
|
||||
best_index = i;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return best_index;
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(
|
||||
wuffs_base__slice_u8 dst,
|
||||
|
||||
@@ -21,6 +21,23 @@
|
||||
// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.
|
||||
typedef uint32_t wuffs_base__color_u32_argb_premul;
|
||||
|
||||
static inline uint8_t //
|
||||
wuffs_base__color_u32_argb_premul__as_gray(
|
||||
wuffs_base__color_u32_argb_premul c) {
|
||||
// Work in 16-bit color.
|
||||
uint32_t cr = 0x101 * (0xFF & (c >> 16));
|
||||
uint32_t cg = 0x101 * (0xFF & (c >> 8));
|
||||
uint32_t cb = 0x101 * (0xFF & (c >> 0));
|
||||
|
||||
// These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
|
||||
// as those given by the JFIF specification.
|
||||
//
|
||||
// Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We
|
||||
// shift by 24, not just by 16, because the return value is 8-bit color, not
|
||||
// 16-bit color.
|
||||
return ((19595 * cr) + (38470 * cg) + (7471 * cb) + 32768) >> 24;
|
||||
}
|
||||
|
||||
// wuffs_base__premul_u32_axxx converts from non-premultiplied alpha to
|
||||
// premultiplied alpha. The "axxx" means either "argb" or "abgr".
|
||||
static inline uint32_t //
|
||||
@@ -1229,6 +1246,23 @@ typedef struct {
|
||||
|
||||
// --------
|
||||
|
||||
// wuffs_base__pixel_palette__closest_element returns the index of the palette
|
||||
// element that minimizes the sum of squared differences of the four ARGB
|
||||
// channels, working in premultiplied alpha. Ties favor the smaller index.
|
||||
//
|
||||
// The palette_slice.len may equal (N*4), for N less than 256, which means that
|
||||
// only the first N palette elements are considered. It returns 0 when N is 0.
|
||||
//
|
||||
// Applying this function on a per-pixel basis will not produce whole-of-image
|
||||
// dithering.
|
||||
uint8_t //
|
||||
wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__slice_u8 palette_slice,
|
||||
wuffs_base__pixel_format palette_format,
|
||||
wuffs_base__color_u32_argb_premul c);
|
||||
|
||||
// --------
|
||||
|
||||
// TODO: should the func type take restrict pointers?
|
||||
typedef uint64_t (*wuffs_base__pixel_swizzler__func)(
|
||||
wuffs_base__slice_u8 dst,
|
||||
|
||||
+11
-5
@@ -32,9 +32,12 @@ const baseImageImplC = "" +
|
||||
"te_impl.planes[0].stride;\n uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {\n uint8_t* palette = pb->private_impl.planes[3].ptr;\n return wuffs_base__load_u32le__no_bounds_check(palette +\n (4 * ((size_t)row[x])));\n }\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[x])));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {\n uint8_t* palette = pb->private_impl.planes[3].ptr;\n return wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(palette +\n " +
|
||||
" (4 * ((size_t)row[x]))));\n }\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {\n uint16_t bgr =\n wuffs_base__load_u16le__no_bounds_check(row + (2 * ((size_t)x)));\n uint32_t b5 = 0x1F & (bgr >> 0);\n uint32_t b = (b5 << 3) | (b5 >> 2);\n uint32_t g6 = 0x3F & (bgr >> 5);\n uint32_t g = (g6 << 2) | (g6 >> 4);\n uint32_t r5 = 0x1F & (bgr >> 11);\n uint32_t r = (r5 << 3) | (r5 >> 2);\n return 0xFF000000 | (r << 16) | (g << 8) | (b << 0);\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return 0xFF000000 |\n wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n return wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return 0xFF000000 |\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_F" +
|
||||
"ORMAT__RGB:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n return wuffs_base__swap_u32_argb_abgr(wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n return wuffs_base__swap_u32_argb_abgr(\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n\n default:\n // TODO: support more formats.\n break;\n }\n\n return 0;\n}\n\nwuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_at(\n wuffs_base__pixel_buffer* pb,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color)" +
|
||||
" {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n if ((x >= pb->pixcfg.private_impl.width) ||\n (y >= pb->pixcfg.private_impl.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n size_t stride = pb->private_impl.planes[0].stride;\n uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__store_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);\n break;\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {\n uint32_t b5 = 0x1F & (color >> (8 - 5));\n uint32_t g6 = 0x3F & (color >> (16 - 6));\n uint32_t r5 =" +
|
||||
" 0x1F & (color >> (24 - 5));\n uint32_t bgr565 = (b5 << 0) | (g6 << 5) | (r5 << 11);\n wuffs_base__store_u16le__no_bounds_check(row + (2 * ((size_t)x)),\n (uint16_t)bgr565);\n break;\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__store_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx(color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n wuffs_base__store_u24le__no_bounds_check(\n row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx(\n wuffs_base__swap_u32_argb_abgr(color)));\n break;\n case WUFFS_BASE__P" +
|
||||
"IXEL_FORMAT__RGBA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n\n default:\n // TODO: support more formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n return wuffs_base__make_status(NULL);\n}\n\n" +
|
||||
" {\n if (!pb) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n if ((x >= pb->pixcfg.private_impl.width) ||\n (y >= pb->pixcfg.private_impl.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n size_t stride = pb->private_impl.planes[0].stride;\n uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (pb->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__store_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);\n break;\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n wuffs_base__store_u8__no_bounds_check(\n row + ((size_t)x), wuffs_base__color_u32_argb_premul__as_gray(color" +
|
||||
"));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n wuffs_base__store_u8__no_bounds_check(\n row + ((size_t)x), wuffs_base__pixel_palette__closest_element(\n wuffs_base__pixel_buffer__palette(pb),\n pb->pixcfg.private_impl.pixfmt, color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {\n uint32_t b5 = 0x1F & (color >> (8 - 5));\n uint32_t g6 = 0x3F & (color >> (16 - 6));\n uint32_t r5 = 0x1F & (color >> (24 - 5));\n uint32_t bgr565 = (b5 << 0) | (g6 << 5) | (r5 << 11);\n wuffs_base__store_u16le__no_bounds_check(row + (2 * ((size_t)x)),\n (uint16_t)bgr565);\n break;\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__store_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x))" +
|
||||
", wuffs_base__nonpremul_u32_axxx(color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n wuffs_base__store_u24le__no_bounds_check(\n row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx(\n wuffs_base__swap_u32_argb_abgr(color)));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n\n default:\n // TODO: support more formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n return wuffs_base__make_status(NULL);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nuint8_t //\nwuffs_base__pixel_palette__closest_element(\n wuffs_base__slice_u8 palette_slice,\n wuffs_base__pixel_format palette_format,\n wuffs_base__color_u32_argb_premul c) {\n size_t n = palette_slice.len / 4;\n if (n > 256) {\n n = 256;\n }\n size_t best_index = 0;\n uint64_t best_score = 0xFFFFFFFFFFFFFFFF;\n\n // Work in 16-bit color.\n uint32_t ca = 0x101 * (0xFF & (c >> 24));\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n switch (palette_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 bool nonpremul = palette_format.repr ==\n WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;\n\n size_t i;\n for (i = 0; i < n; i++) {\n // Work in 16-bit color.\n uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]))" +
|
||||
";\n uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));\n uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));\n uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));\n\n // Convert to premultiplied alpha.\n if (nonpremul && (pa != 0xFFFF)) {\n pb = (pb * pa) / 0xFFFF;\n pg = (pg * pa) / 0xFFFF;\n pr = (pr * pa) / 0xFFFF;\n }\n\n // These deltas are conceptually int32_t (signed) but after squaring,\n // it's equivalent to work in uint32_t (unsigned).\n pb -= cb;\n pg -= cg;\n pr -= cr;\n pa -= ca;\n uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +\n ((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));\n if (best_score > score) {\n best_score = score;\n best_index = i;\n }\n }\n break;\n }\n }\n\n return best_index;\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n 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_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\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 uint32_t s0 = wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0);\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over(\n 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_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\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 uint32_t d0 = wuffs_base__load_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 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_4_4(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_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n if (l" +
|
||||
@@ -227,8 +230,9 @@ const baseImagePrivateH = "" +
|
||||
""
|
||||
|
||||
const baseImagePublicH = "" +
|
||||
"// ---------------- Images\n\n// wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied\n// Alpha, Red, Green, Blue color, as a uint32_t value. Its value is always\n// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.\ntypedef uint32_t wuffs_base__color_u32_argb_premul;\n\n// wuffs_base__premul_u32_axxx converts from non-premultiplied alpha to\n// premultiplied alpha. The \"axxx\" means either \"argb\" or \"abgr\".\nstatic inline uint32_t //\nwuffs_base__premul_u32_axxx(uint32_t nonpremul) {\n // Multiplying by 0x101 (twice, once for alpha and once for color) converts\n // from 8-bit to 16-bit color. Shifting right by 8 undoes that.\n //\n // Working in the higher bit depth can produce slightly different (and\n // arguably slightly more accurate) results. For example, given 8-bit blue\n // and alpha of 0x80 and 0x81:\n //\n // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40\n // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41\n uint32_t a = 0xFF & (nonpremul >> 2" +
|
||||
"4);\n uint32_t a16 = a * (0x101 * 0x101);\n\n uint32_t r = 0xFF & (nonpremul >> 16);\n r = ((r * a16) / 0xFFFF) >> 8;\n uint32_t g = 0xFF & (nonpremul >> 8);\n g = ((g * a16) / 0xFFFF) >> 8;\n uint32_t b = 0xFF & (nonpremul >> 0);\n b = ((b * a16) / 0xFFFF) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n// wuffs_base__nonpremul_u32_axxx converts from premultiplied alpha to\n// non-premultiplied alpha. The \"axxx\" means either \"argb\" or \"abgr\".\nstatic inline uint32_t //\nwuffs_base__nonpremul_u32_axxx(uint32_t premul) {\n uint32_t a = 0xFF & (premul >> 24);\n if (a == 0xFF) {\n return premul;\n } else if (a == 0) {\n return 0;\n }\n uint32_t a16 = a * 0x101;\n\n uint32_t r = 0xFF & (premul >> 16);\n r = ((r * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t g = 0xFF & (premul >> 8);\n g = ((g * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t b = 0xFF & (premul >> 0);\n b = ((b * (0x101 * 0xFFFF)) / a16) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n" +
|
||||
"// ---------------- Images\n\n// wuffs_base__color_u32_argb_premul is an 8 bit per channel premultiplied\n// Alpha, Red, Green, Blue color, as a uint32_t value. Its value is always\n// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.\ntypedef uint32_t wuffs_base__color_u32_argb_premul;\n\nstatic inline uint8_t //\nwuffs_base__color_u32_argb_premul__as_gray(\n wuffs_base__color_u32_argb_premul c) {\n // Work in 16-bit color.\n uint32_t cr = 0x101 * (0xFF & (c >> 16));\n uint32_t cg = 0x101 * (0xFF & (c >> 8));\n uint32_t cb = 0x101 * (0xFF & (c >> 0));\n\n // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same\n // as those given by the JFIF specification.\n //\n // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We\n // shift by 24, not just by 16, because the return value is 8-bit color, not\n // 16-bit color.\n return ((19595 * cr) + (38470 * cg) + (7471 * cb) + 32768) >> 24;\n}\n\n// wuffs_base__premul_u32_axxx converts from non-premultiplied alpha " +
|
||||
"to\n// premultiplied alpha. The \"axxx\" means either \"argb\" or \"abgr\".\nstatic inline uint32_t //\nwuffs_base__premul_u32_axxx(uint32_t nonpremul) {\n // Multiplying by 0x101 (twice, once for alpha and once for color) converts\n // from 8-bit to 16-bit color. Shifting right by 8 undoes that.\n //\n // Working in the higher bit depth can produce slightly different (and\n // arguably slightly more accurate) results. For example, given 8-bit blue\n // and alpha of 0x80 and 0x81:\n //\n // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40\n // - ((0x8080 * 0x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41\n uint32_t a = 0xFF & (nonpremul >> 24);\n uint32_t a16 = a * (0x101 * 0x101);\n\n uint32_t r = 0xFF & (nonpremul >> 16);\n r = ((r * a16) / 0xFFFF) >> 8;\n uint32_t g = 0xFF & (nonpremul >> 8);\n g = ((g * a16) / 0xFFFF) >> 8;\n uint32_t b = 0xFF & (nonpremul >> 0);\n b = ((b * a16) / 0xFFFF) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n// wuffs_base__nonpremul_u32_axxx converts from premultip" +
|
||||
"lied alpha to\n// non-premultiplied alpha. The \"axxx\" means either \"argb\" or \"abgr\".\nstatic inline uint32_t //\nwuffs_base__nonpremul_u32_axxx(uint32_t premul) {\n uint32_t a = 0xFF & (premul >> 24);\n if (a == 0xFF) {\n return premul;\n } else if (a == 0) {\n return 0;\n }\n uint32_t a16 = a * 0x101;\n\n uint32_t r = 0xFF & (premul >> 16);\n r = ((r * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t g = 0xFF & (premul >> 8);\n g = ((g * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t b = 0xFF & (premul >> 0);\n b = ((b * (0x101 * 0xFFFF)) / a16) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\n" +
|
||||
"" +
|
||||
"// --------\n\ntypedef uint8_t wuffs_base__pixel_blend;\n\n// wuffs_base__pixel_blend encodes how to blend source and destination pixels,\n// accounting for transparency. It encompasses the Porter-Duff compositing\n// operators as well as the other blending modes defined by PDF.\n//\n// TODO: implement the other modes.\n#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)\n#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)\n\n" +
|
||||
"" +
|
||||
@@ -282,6 +286,8 @@ const baseImagePublicH = "" +
|
||||
"" +
|
||||
"// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n uint8_t TODO;\n } private_impl;\n\n#ifdef __cplusplus\n#endif // __cplusplus\n\n} wuffs_base__decode_frame_options;\n\n#ifdef __cplusplus\n\n#endif // __cplusplus\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// wuffs_base__pixel_palette__closest_element returns the index of the palette\n// element that minimizes the sum of squared differences of the four ARGB\n// channels, working in premultiplied alpha. Ties favor the smaller index.\n//\n// The palette_slice.len may equal (N*4), for N less than 256, which means that\n// only the first N palette elements are considered. It returns 0 when N is 0.\n//\n// Applying this function on a per-pixel basis will not produce whole-of-image\n// dithering.\nuint8_t //\nwuffs_base__pixel_palette__closest_element(\n wuffs_base__slice_u8 palette_slice,\n wuffs_base__pixel_format palette_format,\n wuffs_base__color_u32_argb_premul c);\n\n" +
|
||||
"" +
|
||||
"// --------\n\n// TODO: should the func type take restrict pointers?\ntypedef uint64_t (*wuffs_base__pixel_swizzler__func)(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src);\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_swizzler__func func;\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status prepare(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 inline uint64_t swizzle_interleaved(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) const;\n#endi" +
|
||||
"f // __cplusplus\n\n} wuffs_base__pixel_swizzler;\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\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\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_swizzler::prepare(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 return wuffs_base__pixel_swizzler__prepare(this, dst_format, dst_palette,\n src_format, src_palette, blend);\n}\n\nuint64_t //\nwuffs_base__pixel_swizzler::swizzle_interleaved(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) const {\n return wuffs_base__pixel_swizzler__swizzle_interleaved(this, dst, dst_palette,\n src);\n}\n\n#endif // __cplusplus\n" +
|
||||
|
||||
@@ -2507,6 +2507,23 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {
|
||||
// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.
|
||||
typedef uint32_t wuffs_base__color_u32_argb_premul;
|
||||
|
||||
static inline uint8_t //
|
||||
wuffs_base__color_u32_argb_premul__as_gray(
|
||||
wuffs_base__color_u32_argb_premul c) {
|
||||
// Work in 16-bit color.
|
||||
uint32_t cr = 0x101 * (0xFF & (c >> 16));
|
||||
uint32_t cg = 0x101 * (0xFF & (c >> 8));
|
||||
uint32_t cb = 0x101 * (0xFF & (c >> 0));
|
||||
|
||||
// These coefficients (the fractions 0.299, 0.587 and 0.114) are the same
|
||||
// as those given by the JFIF specification.
|
||||
//
|
||||
// Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We
|
||||
// shift by 24, not just by 16, because the return value is 8-bit color, not
|
||||
// 16-bit color.
|
||||
return ((19595 * cr) + (38470 * cg) + (7471 * cb) + 32768) >> 24;
|
||||
}
|
||||
|
||||
// wuffs_base__premul_u32_axxx converts from non-premultiplied alpha to
|
||||
// premultiplied alpha. The "axxx" means either "argb" or "abgr".
|
||||
static inline uint32_t //
|
||||
@@ -3715,6 +3732,23 @@ typedef struct {
|
||||
|
||||
// --------
|
||||
|
||||
// wuffs_base__pixel_palette__closest_element returns the index of the palette
|
||||
// element that minimizes the sum of squared differences of the four ARGB
|
||||
// channels, working in premultiplied alpha. Ties favor the smaller index.
|
||||
//
|
||||
// The palette_slice.len may equal (N*4), for N less than 256, which means that
|
||||
// only the first N palette elements are considered. It returns 0 when N is 0.
|
||||
//
|
||||
// Applying this function on a per-pixel basis will not produce whole-of-image
|
||||
// dithering.
|
||||
uint8_t //
|
||||
wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__slice_u8 palette_slice,
|
||||
wuffs_base__pixel_format palette_format,
|
||||
wuffs_base__color_u32_argb_premul c);
|
||||
|
||||
// --------
|
||||
|
||||
// TODO: should the func type take restrict pointers?
|
||||
typedef uint64_t (*wuffs_base__pixel_swizzler__func)(
|
||||
wuffs_base__slice_u8 dst,
|
||||
@@ -8626,6 +8660,18 @@ wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
|
||||
// Common formats above. Rarer formats below.
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y:
|
||||
wuffs_base__store_u8__no_bounds_check(
|
||||
row + ((size_t)x), wuffs_base__color_u32_argb_premul__as_gray(color));
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
|
||||
wuffs_base__store_u8__no_bounds_check(
|
||||
row + ((size_t)x), wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__pixel_buffer__palette(pb),
|
||||
pb->pixcfg.private_impl.pixfmt, color));
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {
|
||||
uint32_t b5 = 0x1F & (color >> (8 - 5));
|
||||
uint32_t g6 = 0x3F & (color >> (16 - 6));
|
||||
@@ -8669,6 +8715,68 @@ wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
|
||||
// --------
|
||||
|
||||
uint8_t //
|
||||
wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__slice_u8 palette_slice,
|
||||
wuffs_base__pixel_format palette_format,
|
||||
wuffs_base__color_u32_argb_premul c) {
|
||||
size_t n = palette_slice.len / 4;
|
||||
if (n > 256) {
|
||||
n = 256;
|
||||
}
|
||||
size_t best_index = 0;
|
||||
uint64_t best_score = 0xFFFFFFFFFFFFFFFF;
|
||||
|
||||
// Work in 16-bit color.
|
||||
uint32_t ca = 0x101 * (0xFF & (c >> 24));
|
||||
uint32_t cr = 0x101 * (0xFF & (c >> 16));
|
||||
uint32_t cg = 0x101 * (0xFF & (c >> 8));
|
||||
uint32_t cb = 0x101 * (0xFF & (c >> 0));
|
||||
|
||||
switch (palette_format.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
|
||||
bool nonpremul = palette_format.repr ==
|
||||
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL;
|
||||
|
||||
size_t i;
|
||||
for (i = 0; i < n; i++) {
|
||||
// Work in 16-bit color.
|
||||
uint32_t pb = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 0]));
|
||||
uint32_t pg = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 1]));
|
||||
uint32_t pr = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 2]));
|
||||
uint32_t pa = 0x101 * ((uint32_t)(palette_slice.ptr[(4 * i) + 3]));
|
||||
|
||||
// Convert to premultiplied alpha.
|
||||
if (nonpremul && (pa != 0xFFFF)) {
|
||||
pb = (pb * pa) / 0xFFFF;
|
||||
pg = (pg * pa) / 0xFFFF;
|
||||
pr = (pr * pa) / 0xFFFF;
|
||||
}
|
||||
|
||||
// These deltas are conceptually int32_t (signed) but after squaring,
|
||||
// it's equivalent to work in uint32_t (unsigned).
|
||||
pb -= cb;
|
||||
pg -= cg;
|
||||
pr -= cr;
|
||||
pa -= ca;
|
||||
uint64_t score = ((uint64_t)(pb * pb)) + ((uint64_t)(pg * pg)) +
|
||||
((uint64_t)(pr * pr)) + ((uint64_t)(pa * pa));
|
||||
if (best_score > score) {
|
||||
best_score = score;
|
||||
best_index = i;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return best_index;
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
static uint64_t //
|
||||
wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(
|
||||
wuffs_base__slice_u8 dst,
|
||||
|
||||
+4
-21
@@ -84,14 +84,6 @@ fill_palette_with_grays(wuffs_base__pixel_buffer* pb) {
|
||||
}
|
||||
}
|
||||
|
||||
void //
|
||||
fill_table(wuffs_base__table_u8 t, uint8_t c) {
|
||||
size_t y;
|
||||
for (y = 0; y < t.height; y++) {
|
||||
memset(t.ptr + (y * t.stride), c, t.width);
|
||||
}
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_pixel_swizzler_swizzle() {
|
||||
CHECK_FOCUS(__func__);
|
||||
@@ -150,19 +142,10 @@ test_wuffs_pixel_swizzler_swizzle() {
|
||||
&src_pixbuf, &src_pixcfg, g_src_slice_u8));
|
||||
fill_palette_with_grays(&src_pixbuf);
|
||||
|
||||
// Set the middle src pixel.
|
||||
if (srcs[s].pixfmt_repr == WUFFS_BASE__PIXEL_FORMAT__Y) {
|
||||
fill_table(wuffs_base__pixel_buffer__plane(&src_pixbuf, 0), 0x44);
|
||||
} else if (srcs[s].pixfmt_repr ==
|
||||
WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY) {
|
||||
fill_table(wuffs_base__pixel_buffer__plane(&src_pixbuf, 0), 0x44);
|
||||
} else {
|
||||
CHECK_STATUS("set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
&src_pixbuf, width / 2, height / 2, srcs[s].pixel));
|
||||
}
|
||||
|
||||
// Check the middle src pixel.
|
||||
// Set and check the middle src pixel.
|
||||
CHECK_STATUS("set_color_u32_at",
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
&src_pixbuf, width / 2, height / 2, srcs[s].pixel));
|
||||
wuffs_base__color_u32_argb_premul have_src_pixel =
|
||||
wuffs_base__pixel_buffer__color_u32_at(&src_pixbuf, width / 2,
|
||||
height / 2);
|
||||
|
||||
Reference in new issue
Block a user