From fabfff05d15ffa493da1b984052f6b7d660e458c Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 5 Jan 2020 13:33:52 +1100 Subject: [PATCH] Have pixel_foo methods take pointer receivers --- internal/cgen/base/image-public.h | 74 +++++++++++++------------- internal/cgen/data.go | 36 ++++++------- release/c/wuffs-unsupported-snapshot.c | 74 +++++++++++++------------- test/c/testlib/testlib.c | 4 +- 4 files changed, 96 insertions(+), 92 deletions(-) diff --git a/internal/cgen/base/image-public.h b/internal/cgen/base/image-public.h index f864d675..f300e175 100644 --- a/internal/cgen/base/image-public.h +++ b/internal/cgen/base/image-public.h @@ -86,41 +86,41 @@ typedef uint32_t wuffs_base__pixel_format; extern const uint32_t wuffs_base__pixel_format__bits_per_channel[16]; static inline bool // -wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) { - return f != 0; +wuffs_base__pixel_format__is_valid(const wuffs_base__pixel_format* f) { + return *f != 0; } // wuffs_base__pixel_format__bits_per_pixel returns the number of bits per // pixel for interleaved pixel formats, and returns 0 for planar pixel formats. static inline uint32_t // -wuffs_base__pixel_format__bits_per_pixel(wuffs_base__pixel_format f) { - if (((f >> 16) & 0x03) != 0) { +wuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) { + if (((*f >> 16) & 0x03) != 0) { return 0; } - return wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 0)] + - wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 4)] + - wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 8)] + - wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 12)]; + return wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 0)] + + wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 4)] + + wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 8)] + + wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 12)]; } static inline bool // -wuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) { - return (f >> 18) & 0x01; +wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) { + return (*f >> 18) & 0x01; } static inline bool // -wuffs_base__pixel_format__is_interleaved(wuffs_base__pixel_format f) { - return ((f >> 16) & 0x03) == 0; +wuffs_base__pixel_format__is_interleaved(const wuffs_base__pixel_format* f) { + return ((*f >> 16) & 0x03) == 0; } static inline bool // -wuffs_base__pixel_format__is_planar(wuffs_base__pixel_format f) { - return ((f >> 16) & 0x03) != 0; +wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) { + return ((*f >> 16) & 0x03) != 0; } static inline uint32_t // -wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) { - return ((f >> 16) & 0x03) + 1; +wuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) { + return ((*f >> 16) & 0x03) + 1; } #define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 @@ -155,31 +155,33 @@ typedef uint32_t wuffs_base__pixel_subsampling; ((wuffs_base__pixel_subsampling)0x313100) static inline uint32_t // -wuffs_base__pixel_subsampling__bias_x(wuffs_base__pixel_subsampling s, +wuffs_base__pixel_subsampling__bias_x(const wuffs_base__pixel_subsampling* s, uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 6; - return (s >> shift) & 0x03; + return (*s >> shift) & 0x03; } static inline uint32_t // -wuffs_base__pixel_subsampling__denominator_x(wuffs_base__pixel_subsampling s, - uint32_t plane) { +wuffs_base__pixel_subsampling__denominator_x( + const wuffs_base__pixel_subsampling* s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 4; - return ((s >> shift) & 0x03) + 1; + return ((*s >> shift) & 0x03) + 1; } static inline uint32_t // -wuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s, +wuffs_base__pixel_subsampling__bias_y(const wuffs_base__pixel_subsampling* s, uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 2; - return (s >> shift) & 0x03; + return (*s >> shift) & 0x03; } static inline uint32_t // -wuffs_base__pixel_subsampling__denominator_y(wuffs_base__pixel_subsampling s, - uint32_t plane) { +wuffs_base__pixel_subsampling__denominator_y( + const wuffs_base__pixel_subsampling* s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 0; - return ((s >> shift) & 0x03) + 1; + return ((*s >> shift) & 0x03) + 1; } // -------- @@ -311,12 +313,12 @@ wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { if (!c) { return 0; } - if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) { // TODO: support planar pixel formats, concious of pixel subsampling. return 0; } uint32_t bits_per_pixel = - wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt); + wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt); if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? return 0; @@ -330,7 +332,7 @@ wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { } n *= bytes_per_pixel; - if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) { if (n > (UINT64_MAX - 1024)) { return 0; } @@ -440,7 +442,7 @@ wuffs_base__image_config__set(wuffs_base__image_config* c, if (!c) { return; } - if (wuffs_base__pixel_format__is_valid(pixfmt)) { + if (wuffs_base__pixel_format__is_valid(&pixfmt)) { c->pixcfg.private_impl.pixfmt = pixfmt; c->pixcfg.private_impl.pixsub = pixsub; c->pixcfg.private_impl.width = width; @@ -805,12 +807,12 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, if (!pixcfg) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } - if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { // TODO: support planar pixel formats, concious of pixel subsampling. return wuffs_base__make_status(wuffs_base__error__unsupported_option); } uint32_t bits_per_pixel = - wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt); + wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? return wuffs_base__make_status(wuffs_base__error__unsupported_option); @@ -819,7 +821,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, uint8_t* ptr = pixbuf_memory.ptr; uint64_t len = pixbuf_memory.len; - if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from // the start of pixbuf_memory. We split from the start, not the end, so // that the both chunks' pointers have the same alignment as the original @@ -870,11 +872,11 @@ wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* b, } memset(b, 0, sizeof(*b)); if (!pixcfg || - wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) { + wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } uint32_t bits_per_pixel = - wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt); + wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? return wuffs_base__make_status(wuffs_base__error__unsupported_option); @@ -898,7 +900,7 @@ wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* b, static inline wuffs_base__slice_u8 // wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) { if (b && - wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) { + wuffs_base__pixel_format__is_indexed(&b->pixcfg.private_impl.pixfmt)) { wuffs_base__table_u8* tab = &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; if ((tab->width == 1024) && (tab->height == 1)) { diff --git a/internal/cgen/data.go b/internal/cgen/data.go index 61762045..e1b4d804 100644 --- a/internal/cgen/data.go +++ b/internal/cgen/data.go @@ -107,25 +107,25 @@ const baseImagePublicH = "" + "" + "// --------\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data.\n//\n// See https://github.com/google/wuffs/blob/master/doc/note/pixel-formats.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x15000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x16000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCR ((wuffs_base__pixel_format)0x20020888)\n#define" + " WUFFS_BASE__PIXEL_FORMAT__YCBCRK ((wuffs_base__pixel_format)0x21038888)\n#define WUFFS_BASE__PIXEL_FORMAT__YCBCRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x25038888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCG ((wuffs_base__pixel_format)0x30020888)\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCGK ((wuffs_base__pixel_format)0x31038888)\n#define WUFFS_BASE__PIXEL_FORMAT__YCOCGA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x35038888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x45040008)\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x46040008)\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY \\\n ((wuffs_base__pixel_format)0x47040008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x40000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x41008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x45008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs" + - "_base__pixel_format)0x46008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY \\\n ((wuffs_base__pixel_format)0x47008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x50000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x51008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x55008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x56008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY \\\n ((wuffs_base__pixel_format)0x57008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x60020888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x61038888)\n\nextern const uint32_t wuffs_base__pixel_format__bits_per_channel[16];\n\nstatic inline bool //\nwuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) {\n return f != 0;\n}\n\n// wuffs_base__pixel_format__bits_per_pixel returns the number of bits per\n// pixel for interleaved pixel formats, and returns 0 for planar p" + - "ixel formats.\nstatic inline uint32_t //\nwuffs_base__pixel_format__bits_per_pixel(wuffs_base__pixel_format f) {\n if (((f >> 16) & 0x03) != 0) {\n return 0;\n }\n return wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 0)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 4)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 8)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 12)];\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) {\n return (f >> 18) & 0x01;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_interleaved(wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x03) == 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_planar(wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x03) != 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x03) + 1;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\n#define WUFFS_B" + - "ASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3\n\n" + + "_base__pixel_format)0x46008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY \\\n ((wuffs_base__pixel_format)0x47008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x50000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x51008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x55008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x56008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY \\\n ((wuffs_base__pixel_format)0x57008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x60020888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x61038888)\n\nextern const uint32_t wuffs_base__pixel_format__bits_per_channel[16];\n\nstatic inline bool //\nwuffs_base__pixel_format__is_valid(const wuffs_base__pixel_format* f) {\n return *f != 0;\n}\n\n// wuffs_base__pixel_format__bits_per_pixel returns the number of bits per\n// pixel for interleaved pixel formats, and returns 0 for " + + "planar pixel formats.\nstatic inline uint32_t //\nwuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) {\n if (((*f >> 16) & 0x03) != 0) {\n return 0;\n }\n return wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 0)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 4)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 8)] +\n wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 12)];\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) {\n return (*f >> 18) & 0x01;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_interleaved(const wuffs_base__pixel_format* f) {\n return ((*f >> 16) & 0x03) == 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) {\n return ((*f >> 16) & 0x03) != 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) {\n return ((*f >> 16) & 0x03) + 1;\n}\n\n#define WUFFS_B" + + "ASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0\n#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3\n\n" + "" + "// --------\n\n// wuffs_base__pixel_subsampling encodes whether sample values cover one pixel\n// or cover multiple pixels.\n//\n// See https://github.com/google/wuffs/blob/master/doc/note/pixel-subsampling.md\n//\n// Do not manipulate its bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE ((wuffs_base__pixel_subsampling)0)\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x303000)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x313100)\n\ns" + - "tatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_x(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_x(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return ((s >> shift) & 0x03) + 1;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_y(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return ((s >> shift) & 0x03) + 1;\n}\n\n" + + "tatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_x(const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (*s >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_x(\n const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return ((*s >> shift) & 0x03) + 1;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_y(const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (*s >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__denominator_y(\n const wuffs_base__pixel_subsampling* s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return ((*s >> shift) & 0x03) + 1;\n}\n\n" + "" + "// --------\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_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height);\n inline void invalidate();\n inline bool is_valid() const;\n inline wuffs_base__pixel_format pixel_format() const;\n inline wuffs_base__pixel_subsampling pixel_subsampling() const;\n inline wuffs_base__rect_ie_u32 bounds() const;\n inline uint32_t width() const;\n inline uint32_t height() const;\n inline uint64_t pixbuf_len() const;\n#endif // __cplusplus\n\n} wuffs_base__pixel_config;\n\nstatic inline wuffs_base__pixel_config //\nwuffs_base__null_pixel_config() {\n wuffs_base__pixel_config ret;\n ret.private_impl.pix" + "fmt = 0;\n ret.private_impl.pixsub = 0;\n ret.private_impl.width = 0;\n ret.private_impl.height = 0;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__pixel_config__set(wuffs_base__pixel_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n if (!c) {\n return;\n }\n if (pixfmt) {\n uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n // TODO: handle things other than 1 byte per pixel.\n if (wh <= ((uint64_t)SIZE_MAX)) {\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n return;\n }\n }\n\n c->private_impl.pixfmt = 0;\n c->private_impl.pixsub = 0;\n c->private_impl.width = 0;\n c->private_impl.height = 0;\n}\n\nstatic inline void //\nwuffs_base__pixel_co" + "nfig__invalidate(wuffs_base__pixel_config* c) {\n if (c) {\n c->private_impl.pixfmt = 0;\n c->private_impl.pixsub = 0;\n c->private_impl.width = 0;\n c->private_impl.height = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__pixel_config__is_valid(const wuffs_base__pixel_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_config__pixel_format(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config__pixel_subsampling(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config__bounds(const wuffs_base__pixel_config* c) {\n if (c) {\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = c->private_impl.width;\n ret.max_excl_y = c->private_impl.height;\n return ret;\n }\n\n wuffs_base__rect_ie_u32 ret;\n ret.min_incl" + - "_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not interleaved) pixbufs? Should it\n// allow decoding into a color model different from the format's intrinsic one?\n// For example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t //\nwuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) {\n if (!c) {\n return 0;\n }\n if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return 0;\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt);\n if ((bits_per_pixel == 0" + - ") || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return 0;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t n =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n if (n > (UINT64_MAX / bytes_per_pixel)) {\n return 0;\n }\n n *= bytes_per_pixel;\n\n if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) {\n if (n > (UINT64_MAX - 1024)) {\n return 0;\n }\n n += 1024;\n }\n\n return n;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::invalidate() {\n wuffs_base__pixel_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__pixel_config::is_valid() const {\n return" + - " wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_config::pixel_format() const {\n return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config::pixel_subsampling() const {\n return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config::bounds() const {\n return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::width() const {\n return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::height() const {\n return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t //\nwuffs_base__pixel_config::pixbuf_len() const {\n return wuffs_base__pixel_config__pixbuf_len(this);\n}\n\n#endif // __cplusplus\n\n" + + "_x = 0;\n ret.min_incl_y = 0;\n ret.max_excl_x = 0;\n ret.max_excl_y = 0;\n return ret;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__width(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_config__height(const wuffs_base__pixel_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\n// TODO: this is the right API for planar (not interleaved) pixbufs? Should it\n// allow decoding into a color model different from the format's intrinsic one?\n// For example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline uint64_t //\nwuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) {\n if (!c) {\n return 0;\n }\n if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return 0;\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt);\n if ((bits_per_pixel ==" + + " 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return 0;\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t n =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n if (n > (UINT64_MAX / bytes_per_pixel)) {\n return 0;\n }\n n *= bytes_per_pixel;\n\n if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) {\n if (n > (UINT64_MAX - 1024)) {\n return 0;\n }\n n += 1024;\n }\n\n return n;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__pixel_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height) {\n wuffs_base__pixel_config__set(this, pixfmt, pixsub, width, height);\n}\n\ninline void //\nwuffs_base__pixel_config::invalidate() {\n wuffs_base__pixel_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__pixel_config::is_valid() const {\n ret" + + "urn wuffs_base__pixel_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_config::pixel_format() const {\n return wuffs_base__pixel_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__pixel_config::pixel_subsampling() const {\n return wuffs_base__pixel_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__pixel_config::bounds() const {\n return wuffs_base__pixel_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::width() const {\n return wuffs_base__pixel_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__pixel_config::height() const {\n return wuffs_base__pixel_config__height(this);\n}\n\ninline uint64_t //\nwuffs_base__pixel_config::pixbuf_len() const {\n return wuffs_base__pixel_config__pixbuf_len(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\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 uint64_t first_frame_io_position;\n bool first_frame_is_opaque;\n } private_impl;\n\n#ifdef __cplusplus\n inline void set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque);\n inline void invalidate();\n inline bool is_valid() const;\n inline uint64_t first_frame_io_position() const;\n inline bool first_frame_is_opaque() const;\n#endif // __cplusplus\n\n} wuffs_base__image_config;\n\nstatic inline wuffs_base__image_config //\nwuffs_base__null_image_config() {\n wuffs_base__image_config ret;\n ret.pixcfg = wuffs_base__null_pixel_config();\n ret.private_impl.first_frame_io_position = 0;\n ret.private_impl.fir" + - "st_frame_is_opaque = false;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__image_config__set(wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n if (!c) {\n return;\n }\n if (wuffs_base__pixel_format__is_valid(pixfmt)) {\n c->pixcfg.private_impl.pixfmt = pixfmt;\n c->pixcfg.private_impl.pixsub = pixsub;\n c->pixcfg.private_impl.width = width;\n c->pixcfg.private_impl.height = height;\n c->private_impl.first_frame_io_position = first_frame_io_position;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n\n c->pixcfg.private_impl.pixfmt = 0;\n c->pixcfg.private_impl.pixsub = 0;\n c->pix" + - "cfg.private_impl.width = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n c->pixcfg.private_impl.pixfmt = 0;\n c->pixcfg.private_impl.pixsub = 0;\n c->pixcfg.private_impl.width = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__image_config__is_valid(const wuffs_base__image_config* c) {\n return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t //\nwuffs_base__image_config__first_frame_io_position(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool //\nwuffs_base__image_config__first_frame_is_opaque(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaqu" + - "e : false;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__set(this, pixfmt, pixsub, width, height,\n first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void //\nwuffs_base__image_config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__image_config::is_valid() const {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline uint64_t //\nwuffs_base__image_config::first_frame_io_position() const {\n return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool //\nwuffs_base__image_config::first_frame_is_opaque() const {\n return wuffs_base__image_co" + - "nfig__first_frame_is_opaque(this);\n}\n\n#endif // __cplusplus\n\n" + + "st_frame_is_opaque = false;\n return ret;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__image_config__set(wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n if (!c) {\n return;\n }\n if (wuffs_base__pixel_format__is_valid(&pixfmt)) {\n c->pixcfg.private_impl.pixfmt = pixfmt;\n c->pixcfg.private_impl.pixsub = pixsub;\n c->pixcfg.private_impl.width = width;\n c->pixcfg.private_impl.height = height;\n c->private_impl.first_frame_io_position = first_frame_io_position;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n\n c->pixcfg.private_impl.pixfmt = 0;\n c->pixcfg.private_impl.pixsub = 0;\n c->pi" + + "xcfg.private_impl.width = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n c->pixcfg.private_impl.pixfmt = 0;\n c->pixcfg.private_impl.pixsub = 0;\n c->pixcfg.private_impl.width = 0;\n c->pixcfg.private_impl.height = 0;\n c->private_impl.first_frame_io_position = 0;\n c->private_impl.first_frame_is_opaque = 0;\n }\n}\n\nstatic inline bool //\nwuffs_base__image_config__is_valid(const wuffs_base__image_config* c) {\n return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg));\n}\n\nstatic inline uint64_t //\nwuffs_base__image_config__first_frame_io_position(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_io_position : 0;\n}\n\nstatic inline bool //\nwuffs_base__image_config__first_frame_is_opaque(\n const wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaq" + + "ue : false;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::set(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint64_t first_frame_io_position,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__set(this, pixfmt, pixsub, width, height,\n first_frame_io_position, first_frame_is_opaque);\n}\n\ninline void //\nwuffs_base__image_config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool //\nwuffs_base__image_config::is_valid() const {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline uint64_t //\nwuffs_base__image_config::first_frame_io_position() const {\n return wuffs_base__image_config__first_frame_io_position(this);\n}\n\ninline bool //\nwuffs_base__image_config::first_frame_is_opaque() const {\n return wuffs_base__image_c" + + "onfig__first_frame_is_opaque(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\n// wuffs_base__animation_blend encodes, for an animated image, how to blend the\n// transparent pixels of this frame with the existing canvas. In Porter-Duff\n// compositing operator terminology:\n// - 0 means the frame may be transparent, and should be blended \"src over\n// dst\", also known as just \"over\".\n// - 1 means the frame may be transparent, and should be blended \"src\".\n// - 2 means the frame is completely opaque, so that \"src over dst\" and \"src\"\n// are equivalent.\n//\n// These semantics are conservative. It is valid for a completely opaque frame\n// to have a blend value other than 2.\ntypedef uint8_t wuffs_base__animation_blend;\n\n#define WUFFS_BASE__ANIMATION_BLEND__SRC_OVER_DST \\\n ((wuffs_base__animation_blend)0)\n#define WUFFS_BASE__ANIMATION_BLEND__SRC ((wuffs_base__animation_blend)1)\n#define WUFFS_BASE__ANIMATION_BLEND__OPAQUE ((wuffs_base__animation_blend)2)\n\n" + "" + @@ -140,13 +140,13 @@ const baseImagePublicH = "" + "g::background_color() const {\n return wuffs_base__frame_config__background_color(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\ntypedef struct {\n wuffs_base__pixel_config pixcfg;\n\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__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n // TODO: color spaces.\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_slice(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory);\n inline wuffs_base__status set_from_table(\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 pixbuf_memory);\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__pixel_format pixel_format() const;\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__pixel_buffer;\n\nstatic inline wuffs_base__pixel_buffer //\nwuffs_base__null_pixel_buffer() {\n wuffs_base__pixel_buffer ret;\n ret.pixcfg = wuffs_base__null_pixel_config();\n ret.private_impl.planes[0] = wuffs_base__empty_table_u8" + - "();\n ret.private_impl.planes[1] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[2] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[3] = wuffs_base__empty_table_u8();\n return ret;\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(b, 0, sizeof(*b));\n if (!pixcfg) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt);\n if ((bits_per_pi" + - "xel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {\n // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n // the start of pixbuf_memory. We split from the start, not the end, so\n // that the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < 1024) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = 1024;\n tab->height = 1;\n tab->stride = 1024;\n ptr += 1024;\n len -= 102" + - "4;\n }\n\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n size_t width = (size_t)(pixcfg->private_impl.width);\n if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n (width > (SIZE_MAX / bytes_per_pixel))) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n wh *= bytes_per_pixel;\n width *= bytes_per_pixel;\n if (wh > len) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n\n b->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = width;\n return wuffs_base__make_status(NULL);\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* b,\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 pixbuf_memory) {\n if (!b)" + - " {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(b, 0, sizeof(*b));\n if (!pixcfg ||\n wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t width_in_bytes =\n ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;\n if ((width_in_bytes > pixbuf_memory.width) ||\n (pixcfg->private_impl.height > pixbuf_memory.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n b->pixcfg = *pixcfg;\n b->private_impl.planes[0] = pixbuf_memory;\n return wuffs_base__make_status(NULL);\n}\n\n// wu" + - "ffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it will have length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n if (b &&\n wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width == 1024) && (tab->height == 1)) {\n return wuffs_base__make_slice_u8(tab->ptr, 1024);\n }\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer__pixel_format(const wuffs_base__pixel_buffer* b) {\n if (b) {\n return b->pixcfg.private_impl.pixfmt;\n }\n return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n if (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) {\n return b->private_impl.planes[p];\n }\n\n w" + - "uffs_base__table_u8 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_table(const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_table(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() const {\n return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t p) {\n " + - " return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n" + + "();\n ret.private_impl.planes[1] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[2] = wuffs_base__empty_table_u8();\n ret.private_impl.planes[3] = wuffs_base__empty_table_u8();\n return ret;\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(b, 0, sizeof(*b));\n if (!pixcfg) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n // TODO: support planar pixel formats, concious of pixel subsampling.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_" + + "pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint8_t* ptr = pixbuf_memory.ptr;\n uint64_t len = pixbuf_memory.len;\n if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) {\n // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from\n // the start of pixbuf_memory. We split from the start, not the end, so\n // that the both chunks' pointers have the same alignment as the original\n // pointer, up to an alignment of 1024.\n if (len < 1024) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n tab->ptr = ptr;\n tab->width = 1024;\n tab->height = 1;\n tab->stride = 1024;\n ptr += 1024;\n len -= " + + "1024;\n }\n\n uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *\n ((uint64_t)pixcfg->private_impl.height);\n size_t width = (size_t)(pixcfg->private_impl.width);\n if ((wh > (UINT64_MAX / bytes_per_pixel)) ||\n (width > (SIZE_MAX / bytes_per_pixel))) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n wh *= bytes_per_pixel;\n width *= bytes_per_pixel;\n if (wh > len) {\n return wuffs_base__make_status(\n wuffs_base__error__bad_argument_length_too_short);\n }\n\n b->pixcfg = *pixcfg;\n wuffs_base__table_u8* tab = &b->private_impl.planes[0];\n tab->ptr = ptr;\n tab->width = width;\n tab->height = pixcfg->private_impl.height;\n tab->stride = width;\n return wuffs_base__make_status(NULL);\n}\n\nstatic inline wuffs_base__status //\nwuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* b,\n const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 pixbuf_memory) {\n if (" + + "!b) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n memset(b, 0, sizeof(*b));\n if (!pixcfg ||\n wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n uint32_t bits_per_pixel =\n wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt);\n if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) {\n // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel?\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n uint64_t bytes_per_pixel = bits_per_pixel / 8;\n\n uint64_t width_in_bytes =\n ((uint64_t)pixcfg->private_impl.width) * bytes_per_pixel;\n if ((width_in_bytes > pixbuf_memory.width) ||\n (pixcfg->private_impl.height > pixbuf_memory.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n b->pixcfg = *pixcfg;\n b->private_impl.planes[0] = pixbuf_memory;\n return wuffs_base__make_status(NULL);\n}\n\n" + + "// wuffs_base__pixel_buffer__palette returns the palette color data. If\n// non-empty, it will have length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {\n if (b &&\n wuffs_base__pixel_format__is_indexed(&b->pixcfg.private_impl.pixfmt)) {\n wuffs_base__table_u8* tab =\n &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];\n if ((tab->width == 1024) && (tab->height == 1)) {\n return wuffs_base__make_slice_u8(tab->ptr, 1024);\n }\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer__pixel_format(const wuffs_base__pixel_buffer* b) {\n if (b) {\n return b->pixcfg.private_impl.pixfmt;\n }\n return WUFFS_BASE__PIXEL_FORMAT__INVALID;\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {\n if (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) {\n return b->private_impl.planes[p];\n " + + "}\n\n wuffs_base__table_u8 ret;\n ret.ptr = NULL;\n ret.width = 0;\n ret.height = 0;\n ret.stride = 0;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_slice(const wuffs_base__pixel_config* pixcfg,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__status //\nwuffs_base__pixel_buffer::set_from_table(const wuffs_base__pixel_config* pixcfg,\n wuffs_base__table_u8 pixbuf_memory) {\n return wuffs_base__pixel_buffer__set_from_table(this, pixcfg, pixbuf_memory);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__pixel_buffer::palette() {\n return wuffs_base__pixel_buffer__palette(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__pixel_buffer::pixel_format() const {\n return wuffs_base__pixel_buffer__pixel_format(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__pixel_buffer::plane(uint32_t " + + "p) {\n return wuffs_base__pixel_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\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" + "" + diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 86180b31..f32e6d2a 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -1528,41 +1528,41 @@ typedef uint32_t wuffs_base__pixel_format; extern const uint32_t wuffs_base__pixel_format__bits_per_channel[16]; static inline bool // -wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) { - return f != 0; +wuffs_base__pixel_format__is_valid(const wuffs_base__pixel_format* f) { + return *f != 0; } // wuffs_base__pixel_format__bits_per_pixel returns the number of bits per // pixel for interleaved pixel formats, and returns 0 for planar pixel formats. static inline uint32_t // -wuffs_base__pixel_format__bits_per_pixel(wuffs_base__pixel_format f) { - if (((f >> 16) & 0x03) != 0) { +wuffs_base__pixel_format__bits_per_pixel(const wuffs_base__pixel_format* f) { + if (((*f >> 16) & 0x03) != 0) { return 0; } - return wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 0)] + - wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 4)] + - wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 8)] + - wuffs_base__pixel_format__bits_per_channel[0x0F & (f >> 12)]; + return wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 0)] + + wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 4)] + + wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 8)] + + wuffs_base__pixel_format__bits_per_channel[0x0F & (*f >> 12)]; } static inline bool // -wuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) { - return (f >> 18) & 0x01; +wuffs_base__pixel_format__is_indexed(const wuffs_base__pixel_format* f) { + return (*f >> 18) & 0x01; } static inline bool // -wuffs_base__pixel_format__is_interleaved(wuffs_base__pixel_format f) { - return ((f >> 16) & 0x03) == 0; +wuffs_base__pixel_format__is_interleaved(const wuffs_base__pixel_format* f) { + return ((*f >> 16) & 0x03) == 0; } static inline bool // -wuffs_base__pixel_format__is_planar(wuffs_base__pixel_format f) { - return ((f >> 16) & 0x03) != 0; +wuffs_base__pixel_format__is_planar(const wuffs_base__pixel_format* f) { + return ((*f >> 16) & 0x03) != 0; } static inline uint32_t // -wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) { - return ((f >> 16) & 0x03) + 1; +wuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) { + return ((*f >> 16) & 0x03) + 1; } #define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 @@ -1597,31 +1597,33 @@ typedef uint32_t wuffs_base__pixel_subsampling; ((wuffs_base__pixel_subsampling)0x313100) static inline uint32_t // -wuffs_base__pixel_subsampling__bias_x(wuffs_base__pixel_subsampling s, +wuffs_base__pixel_subsampling__bias_x(const wuffs_base__pixel_subsampling* s, uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 6; - return (s >> shift) & 0x03; + return (*s >> shift) & 0x03; } static inline uint32_t // -wuffs_base__pixel_subsampling__denominator_x(wuffs_base__pixel_subsampling s, - uint32_t plane) { +wuffs_base__pixel_subsampling__denominator_x( + const wuffs_base__pixel_subsampling* s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 4; - return ((s >> shift) & 0x03) + 1; + return ((*s >> shift) & 0x03) + 1; } static inline uint32_t // -wuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s, +wuffs_base__pixel_subsampling__bias_y(const wuffs_base__pixel_subsampling* s, uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 2; - return (s >> shift) & 0x03; + return (*s >> shift) & 0x03; } static inline uint32_t // -wuffs_base__pixel_subsampling__denominator_y(wuffs_base__pixel_subsampling s, - uint32_t plane) { +wuffs_base__pixel_subsampling__denominator_y( + const wuffs_base__pixel_subsampling* s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 0; - return ((s >> shift) & 0x03) + 1; + return ((*s >> shift) & 0x03) + 1; } // -------- @@ -1753,12 +1755,12 @@ wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { if (!c) { return 0; } - if (wuffs_base__pixel_format__is_planar(c->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_planar(&c->private_impl.pixfmt)) { // TODO: support planar pixel formats, concious of pixel subsampling. return 0; } uint32_t bits_per_pixel = - wuffs_base__pixel_format__bits_per_pixel(c->private_impl.pixfmt); + wuffs_base__pixel_format__bits_per_pixel(&c->private_impl.pixfmt); if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? return 0; @@ -1772,7 +1774,7 @@ wuffs_base__pixel_config__pixbuf_len(const wuffs_base__pixel_config* c) { } n *= bytes_per_pixel; - if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_indexed(&c->private_impl.pixfmt)) { if (n > (UINT64_MAX - 1024)) { return 0; } @@ -1882,7 +1884,7 @@ wuffs_base__image_config__set(wuffs_base__image_config* c, if (!c) { return; } - if (wuffs_base__pixel_format__is_valid(pixfmt)) { + if (wuffs_base__pixel_format__is_valid(&pixfmt)) { c->pixcfg.private_impl.pixfmt = pixfmt; c->pixcfg.private_impl.pixsub = pixsub; c->pixcfg.private_impl.width = width; @@ -2247,12 +2249,12 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, if (!pixcfg) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } - if (wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { // TODO: support planar pixel formats, concious of pixel subsampling. return wuffs_base__make_status(wuffs_base__error__unsupported_option); } uint32_t bits_per_pixel = - wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt); + wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? return wuffs_base__make_status(wuffs_base__error__unsupported_option); @@ -2261,7 +2263,7 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b, uint8_t* ptr = pixbuf_memory.ptr; uint64_t len = pixbuf_memory.len; - if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) { + if (wuffs_base__pixel_format__is_indexed(&pixcfg->private_impl.pixfmt)) { // Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from // the start of pixbuf_memory. We split from the start, not the end, so // that the both chunks' pointers have the same alignment as the original @@ -2312,11 +2314,11 @@ wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* b, } memset(b, 0, sizeof(*b)); if (!pixcfg || - wuffs_base__pixel_format__is_planar(pixcfg->private_impl.pixfmt)) { + wuffs_base__pixel_format__is_planar(&pixcfg->private_impl.pixfmt)) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } uint32_t bits_per_pixel = - wuffs_base__pixel_format__bits_per_pixel(pixcfg->private_impl.pixfmt); + wuffs_base__pixel_format__bits_per_pixel(&pixcfg->private_impl.pixfmt); if ((bits_per_pixel == 0) || ((bits_per_pixel % 8) != 0)) { // TODO: support fraction-of-byte pixels, e.g. 1 bit per pixel? return wuffs_base__make_status(wuffs_base__error__unsupported_option); @@ -2340,7 +2342,7 @@ wuffs_base__pixel_buffer__set_from_table(wuffs_base__pixel_buffer* b, static inline wuffs_base__slice_u8 // wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) { if (b && - wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) { + wuffs_base__pixel_format__is_indexed(&b->pixcfg.private_impl.pixfmt)) { wuffs_base__table_u8* tab = &b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE]; if ((tab->width == 1024) && (tab->height == 1)) { diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index 39dd6fce..9dc8e7ed 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -443,12 +443,12 @@ const char* copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst, wuffs_base__pixel_format pixfmt = wuffs_base__pixel_config__pixel_format(&src->pixcfg); - if (wuffs_base__pixel_format__is_planar(pixfmt)) { + if (wuffs_base__pixel_format__is_planar(&pixfmt)) { // If we want to support planar pixel buffers, in the future, be concious // of pixel subsampling. return "copy_to_io_buffer_from_pixel_buffer: cannot copy from planar src"; } - uint32_t bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(pixfmt); + uint32_t bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&pixfmt); if (bits_per_pixel == 0) { return "copy_to_io_buffer_from_pixel_buffer: invalid bits_per_pixel"; } else if ((bits_per_pixel % 8) != 0) {