From caa55fe101fc6302c51839a49b07721705c8d752 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 14 Jul 2018 11:35:00 +1000 Subject: [PATCH] Place base func names at line start --- cmd/wuffs-c/internal/cgen/base/base-impl.c | 3 +- cmd/wuffs-c/internal/cgen/base/base-private.h | 308 +++--- cmd/wuffs-c/internal/cgen/base/base-public.h | 650 ++++++------ cmd/wuffs-c/internal/cgen/data.go | 135 +-- release/c/unsupported-snapshot.h | 961 ++++++++++-------- 5 files changed, 1137 insertions(+), 920 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/base-impl.c b/cmd/wuffs-c/internal/cgen/base/base-impl.c index 3cd734c3..8b45f58e 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-impl.c +++ b/cmd/wuffs-c/internal/cgen/base/base-impl.c @@ -24,7 +24,8 @@ // !! INSERT wuffs_base__status__string data. -const char* wuffs_base__status__string(wuffs_base__status s) { +const char* // +wuffs_base__status__string(wuffs_base__status s) { uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)]; return o ? wuffs_base__status__string_data + o : "unknown status"; } diff --git a/cmd/wuffs-c/internal/cgen/base/base-private.h b/cmd/wuffs-c/internal/cgen/base/base-private.h index dec9a489..9025de77 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-private.h +++ b/cmd/wuffs-c/internal/cgen/base/base-private.h @@ -81,90 +81,106 @@ extern "C" { // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -static inline wuffs_base__empty_struct wuffs_base__return_empty_struct() { +static inline wuffs_base__empty_struct // +wuffs_base__return_empty_struct() { return ((wuffs_base__empty_struct){}); } // ---------------- Numeric Types -static inline uint8_t wuffs_base__load_u8be(uint8_t* p) { +static inline uint8_t // +wuffs_base__load_u8be(uint8_t* p) { return p[0]; } -static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { +static inline uint16_t // +wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); } -static inline uint16_t wuffs_base__load_u16le(uint8_t* p) { +static inline uint16_t // +wuffs_base__load_u16le(uint8_t* p) { return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8); } -static inline uint32_t wuffs_base__load_u24be(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u24be(uint8_t* p) { return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 0); } -static inline uint32_t wuffs_base__load_u24le(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u24le(uint8_t* p) { return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 16); } -static inline uint32_t wuffs_base__load_u32be(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u32be(uint8_t* p) { return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) | ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0); } -static inline uint32_t wuffs_base__load_u32le(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u32le(uint8_t* p) { return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); } -static inline uint64_t wuffs_base__load_u40be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u40be(uint8_t* p) { return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) | ((uint64_t)(p[4]) << 0); } -static inline uint64_t wuffs_base__load_u40le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u40le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32); } -static inline uint64_t wuffs_base__load_u48be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u48be(uint8_t* p) { return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) | ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) | ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0); } -static inline uint64_t wuffs_base__load_u48le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u48le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40); } -static inline uint64_t wuffs_base__load_u56be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u56be(uint8_t* p) { return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) | ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) | ((uint64_t)(p[6]) << 0); } -static inline uint64_t wuffs_base__load_u56le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u56le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | ((uint64_t)(p[6]) << 48); } -static inline uint64_t wuffs_base__load_u64be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u64be(uint8_t* p) { return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) | ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) | ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) | ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0); } -static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u64le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | @@ -173,47 +189,55 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- -static inline void wuffs_base__store_u8be(uint8_t* p, uint8_t x) { +static inline void // +wuffs_base__store_u8be(uint8_t* p, uint8_t x) { p[0] = x; } -static inline void wuffs_base__store_u16be(uint8_t* p, uint16_t x) { +static inline void // +wuffs_base__store_u16be(uint8_t* p, uint16_t x) { p[0] = x >> 8; p[1] = x >> 0; } -static inline void wuffs_base__store_u16le(uint8_t* p, uint16_t x) { +static inline void // +wuffs_base__store_u16le(uint8_t* p, uint16_t x) { p[0] = x >> 0; p[1] = x >> 8; } -static inline void wuffs_base__store_u24be(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u24be(uint8_t* p, uint32_t x) { p[0] = x >> 16; p[1] = x >> 8; p[2] = x >> 0; } -static inline void wuffs_base__store_u24le(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u24le(uint8_t* p, uint32_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; } -static inline void wuffs_base__store_u32be(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u32be(uint8_t* p, uint32_t x) { p[0] = x >> 24; p[1] = x >> 16; p[2] = x >> 8; p[3] = x >> 0; } -static inline void wuffs_base__store_u32le(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u32le(uint8_t* p, uint32_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; p[3] = x >> 24; } -static inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u40be(uint8_t* p, uint64_t x) { p[0] = x >> 32; p[1] = x >> 24; p[2] = x >> 16; @@ -221,7 +245,8 @@ static inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) { p[4] = x >> 0; } -static inline void wuffs_base__store_u40le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u40le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -229,7 +254,8 @@ static inline void wuffs_base__store_u40le(uint8_t* p, uint64_t x) { p[4] = x >> 32; } -static inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u48be(uint8_t* p, uint64_t x) { p[0] = x >> 40; p[1] = x >> 32; p[2] = x >> 24; @@ -238,7 +264,8 @@ static inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) { p[5] = x >> 0; } -static inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u48le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -247,7 +274,8 @@ static inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) { p[5] = x >> 40; } -static inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u56be(uint8_t* p, uint64_t x) { p[0] = x >> 48; p[1] = x >> 40; p[2] = x >> 32; @@ -257,7 +285,8 @@ static inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) { p[6] = x >> 0; } -static inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u56le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -267,7 +296,8 @@ static inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) { p[6] = x >> 48; } -static inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u64be(uint8_t* p, uint64_t x) { p[0] = x >> 56; p[1] = x >> 48; p[2] = x >> 40; @@ -278,7 +308,8 @@ static inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) { p[7] = x >> 0; } -static inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u64le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -291,43 +322,50 @@ static inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) { // -------- -static inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { +static inline void // +wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { *x = wuffs_base__u8__sat_add(*x, y); } -static inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { +static inline void // +wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { *x = wuffs_base__u8__sat_sub(*x, y); } -static inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { +static inline void // +wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { *x = wuffs_base__u16__sat_add(*x, y); } -static inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { +static inline void // +wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { *x = wuffs_base__u16__sat_sub(*x, y); } -static inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { +static inline void // +wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { *x = wuffs_base__u32__sat_add(*x, y); } -static inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { +static inline void // +wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { *x = wuffs_base__u32__sat_sub(*x, y); } -static inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { +static inline void // +wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { *x = wuffs_base__u64__sat_add(*x, y); } -static inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { +static inline void // +wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { *x = wuffs_base__u64__sat_sub(*x, y); } // ---------------- Slices and Tables -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( - wuffs_base__slice_u8 s, - uint64_t i) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) { if ((i <= SIZE_MAX) && (i <= s.len)) { return ((wuffs_base__slice_u8){ .ptr = s.ptr + i, @@ -337,19 +375,18 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( return ((wuffs_base__slice_u8){}); } -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j( - wuffs_base__slice_u8 s, - uint64_t j) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) { if ((j <= SIZE_MAX) && (j <= s.len)) { return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j}); } return ((wuffs_base__slice_u8){}); } -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij( - wuffs_base__slice_u8 s, - uint64_t i, - uint64_t j) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, + uint64_t i, + uint64_t j) { if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) { return ((wuffs_base__slice_u8){ .ptr = s.ptr + i, @@ -360,9 +397,8 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij( } // wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s. -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix( - wuffs_base__slice_u8 s, - uint64_t up_to) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) { if ((uint64_t)(s.len) > up_to) { s.len = up_to; } @@ -370,9 +406,8 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix( } // wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s. -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix( - wuffs_base__slice_u8 s, - uint64_t up_to) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) { if ((uint64_t)(s.len) > up_to) { s.ptr += (uint64_t)(s.len) - up_to; s.len = up_to; @@ -385,9 +420,9 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix( // // Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty // slice) is valid and results in a no-op. -static inline uint64_t wuffs_base__slice_u8__copy_from_slice( - wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 src) { +static inline uint64_t // +wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { size_t length = dst.len < src.len ? dst.len : src.len; if (length > 0) { memmove(dst.ptr, src.ptr, length); @@ -397,9 +432,8 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( // -------- -static inline wuffs_base__slice_u8 wuffs_base__table_u8__row( - wuffs_base__table_u8 t, - uint32_t y) { +static inline wuffs_base__slice_u8 // +wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { if (y < t.height) { return ((wuffs_base__slice_u8){ .ptr = t.ptr + (t.stride * y), @@ -411,52 +445,52 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row( // ---------------- Utility -static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32( - wuffs_base__utility* ignored, - uint32_t min_incl, - uint32_t max_incl) { +static inline wuffs_base__range_ii_u32 // +wuffs_base__utility__make_range_ii_u32(wuffs_base__utility* ignored, + uint32_t min_incl, + uint32_t max_incl) { return ((wuffs_base__range_ii_u32){ .min_incl = min_incl, .max_incl = max_incl, }); } -static inline wuffs_base__range_ie_u32 wuffs_base__utility__make_range_ie_u32( - wuffs_base__utility* ignored, - uint32_t min_incl, - uint32_t max_excl) { +static inline wuffs_base__range_ie_u32 // +wuffs_base__utility__make_range_ie_u32(wuffs_base__utility* ignored, + uint32_t min_incl, + uint32_t max_excl) { return ((wuffs_base__range_ie_u32){ .min_incl = min_incl, .max_excl = max_excl, }); } -static inline wuffs_base__range_ii_u64 wuffs_base__utility__make_range_ii_u64( - wuffs_base__utility* ignored, - uint64_t min_incl, - uint64_t max_incl) { +static inline wuffs_base__range_ii_u64 // +wuffs_base__utility__make_range_ii_u64(wuffs_base__utility* ignored, + uint64_t min_incl, + uint64_t max_incl) { return ((wuffs_base__range_ii_u64){ .min_incl = min_incl, .max_incl = max_incl, }); } -static inline wuffs_base__range_ie_u64 wuffs_base__utility__make_range_ie_u64( - wuffs_base__utility* ignored, - uint64_t min_incl, - uint64_t max_excl) { +static inline wuffs_base__range_ie_u64 // +wuffs_base__utility__make_range_ie_u64(wuffs_base__utility* ignored, + uint64_t min_incl, + uint64_t max_excl) { return ((wuffs_base__range_ie_u64){ .min_incl = min_incl, .max_excl = max_excl, }); } -static inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32( - wuffs_base__utility* ignored, - uint32_t min_incl_x, - uint32_t min_incl_y, - uint32_t max_incl_x, - uint32_t max_incl_y) { +static inline wuffs_base__rect_ii_u32 // +wuffs_base__utility__make_rect_ii_u32(wuffs_base__utility* ignored, + uint32_t min_incl_x, + uint32_t min_incl_y, + uint32_t max_incl_x, + uint32_t max_incl_y) { return ((wuffs_base__rect_ii_u32){ .min_incl_x = min_incl_x, .min_incl_y = min_incl_y, @@ -465,12 +499,12 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32( }); } -static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32( - wuffs_base__utility* ignored, - uint32_t min_incl_x, - uint32_t min_incl_y, - uint32_t max_excl_x, - uint32_t max_excl_y) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored, + uint32_t min_incl_x, + uint32_t min_incl_y, + uint32_t max_excl_x, + uint32_t max_excl_y) { return ((wuffs_base__rect_ie_u32){ .min_incl_x = min_incl_x, .min_incl_y = min_incl_y, @@ -481,17 +515,20 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32( // ---------------- I/O -static inline bool wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { +static inline bool // +wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) && (buf.wi >= buf.ri); } -static inline bool wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) { +static inline bool // +wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.bounds[1]); } -static inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { +static inline bool // +wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) bounds. @@ -502,7 +539,8 @@ static inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { (o.private_impl.bounds[1] == NULL)); } -static inline bool wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { +static inline bool // +wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) bounds. @@ -513,12 +551,12 @@ static inline bool wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { (o.private_impl.bounds[1] == NULL)); } -static inline uint32_t wuffs_base__io_writer__copy_n_from_history( - uint8_t** ptr_ptr, - uint8_t* start, - uint8_t* end, - uint32_t length, - uint32_t distance) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr, + uint8_t* start, + uint8_t* end, + uint32_t length, + uint32_t distance) { if (!distance) { return 0; } @@ -561,12 +599,12 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_history( // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast( - uint8_t** ptr_ptr, - uint8_t* start, - uint8_t* end, - uint32_t length, - uint32_t distance) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr, + uint8_t* start, + uint8_t* end, + uint32_t length, + uint32_t distance) { uint8_t* ptr = *ptr_ptr; start = ptr - distance; uint32_t n = length; @@ -582,12 +620,12 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast( return length; } -static inline uint32_t wuffs_base__io_writer__copy_n_from_reader( - uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, - uint32_t length, - uint8_t** ptr_ioptr_r, - uint8_t* iobounds1_r) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w, + uint8_t* iobounds1_w, + uint32_t length, + uint8_t** ptr_ioptr_r, + uint8_t* iobounds1_r) { uint8_t* ioptr_w = *ptr_ioptr_w; size_t n = length; if (n > ((size_t)(iobounds1_w - ioptr_w))) { @@ -605,10 +643,10 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_reader( return n; } -static inline uint64_t wuffs_base__io_writer__copy_from_slice( - uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, - wuffs_base__slice_u8 src) { +static inline uint64_t // +wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w, + uint8_t* iobounds1_w, + wuffs_base__slice_u8 src) { uint8_t* ioptr_w = *ptr_ioptr_w; size_t n = src.len; if (n > ((size_t)(iobounds1_w - ioptr_w))) { @@ -621,11 +659,11 @@ static inline uint64_t wuffs_base__io_writer__copy_from_slice( return n; } -static inline uint32_t wuffs_base__io_writer__copy_n_from_slice( - uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, - uint32_t length, - wuffs_base__slice_u8 src) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w, + uint8_t* iobounds1_w, + uint32_t length, + wuffs_base__slice_u8 src) { uint8_t* ioptr_w = *ptr_ioptr_w; size_t n = src.len; if (n > length) { @@ -641,29 +679,28 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_slice( return n; } -static inline wuffs_base__empty_struct wuffs_base__io_reader__set_limit( - wuffs_base__io_reader* o, - uint8_t* ioptr_r, - uint64_t limit) { +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, + uint8_t* ioptr_r, + uint64_t limit) { if (o && (((size_t)(o->private_impl.bounds[1] - ioptr_r)) > limit)) { o->private_impl.bounds[1] = ioptr_r + limit; } return ((wuffs_base__empty_struct){}); } -static inline wuffs_base__empty_struct wuffs_base__io_reader__set_mark( - wuffs_base__io_reader* o, - uint8_t* mark) { +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.bounds[0] = mark; return ((wuffs_base__empty_struct){}); } -static inline wuffs_base__empty_struct wuffs_base__io_writer__set( - wuffs_base__io_writer* o, - wuffs_base__io_buffer* b, - uint8_t** ioptr1_ptr, - uint8_t** ioptr2_ptr, - wuffs_base__slice_u8 s) { +static inline wuffs_base__empty_struct // +wuffs_base__io_writer__set(wuffs_base__io_writer* o, + wuffs_base__io_buffer* b, + uint8_t** ioptr1_ptr, + uint8_t** ioptr2_ptr, + wuffs_base__slice_u8 s) { b->ptr = s.ptr; b->len = s.len; b->wi = 0; @@ -677,9 +714,8 @@ static inline wuffs_base__empty_struct wuffs_base__io_writer__set( return ((wuffs_base__empty_struct){}); } -static inline wuffs_base__empty_struct wuffs_base__io_writer__set_mark( - wuffs_base__io_writer* o, - uint8_t* mark) { +static inline wuffs_base__empty_struct // +wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.bounds[0] = mark; return ((wuffs_base__empty_struct){}); } diff --git a/cmd/wuffs-c/internal/cgen/base/base-public.h b/cmd/wuffs-c/internal/cgen/base/base-public.h index 42f2ec5c..18c3b1ae 100644 --- a/cmd/wuffs-c/internal/cgen/base/base-public.h +++ b/cmd/wuffs-c/internal/cgen/base/base-public.h @@ -108,19 +108,23 @@ typedef int32_t wuffs_base__status; // !! INSERT wuffs_base__status names. -static inline bool wuffs_base__status__is_error(wuffs_base__status s) { +static inline bool // +wuffs_base__status__is_error(wuffs_base__status s) { return s < 0; } -static inline bool wuffs_base__status__is_ok(wuffs_base__status s) { +static inline bool // +wuffs_base__status__is_ok(wuffs_base__status s) { return s == 0; } -static inline bool wuffs_base__status__is_suspension(wuffs_base__status s) { +static inline bool // +wuffs_base__status__is_suspension(wuffs_base__status s) { return s > 0; } -const char* wuffs_base__status__string(wuffs_base__status s); +const char* // +wuffs_base__status__string(wuffs_base__status s); // -------- @@ -133,35 +137,43 @@ typedef int64_t wuffs_base__flicks; // ---------------- Numeric Types -static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__min(uint8_t x, uint8_t y) { return x < y ? x : y; } -static inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__max(uint8_t x, uint8_t y) { return x > y ? x : y; } -static inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__min(uint16_t x, uint16_t y) { return x < y ? x : y; } -static inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__max(uint16_t x, uint16_t y) { return x > y ? x : y; } -static inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__min(uint32_t x, uint32_t y) { return x < y ? x : y; } -static inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__max(uint32_t x, uint32_t y) { return x > y ? x : y; } -static inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__min(uint64_t x, uint64_t y) { return x < y ? x : y; } -static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__max(uint64_t x, uint64_t y) { return x > y ? x : y; } @@ -173,49 +185,57 @@ static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) { // It is important that the underlying types are unsigned integers, as signed // integer arithmetic overflow is undefined behavior in C. -static inline uint8_t wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { uint8_t res = x + y; res |= -(res < x); return res; } -static inline uint8_t wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { uint8_t res = x - y; res &= -(res <= x); return res; } -static inline uint16_t wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { uint16_t res = x + y; res |= -(res < x); return res; } -static inline uint16_t wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { uint16_t res = x - y; res &= -(res <= x); return res; } -static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { uint32_t res = x + y; res |= -(res < x); return res; } -static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) { uint32_t res = x - y; res &= -(res <= x); return res; } -static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__sat_add(uint64_t x, uint64_t y) { uint64_t res = x + y; res |= -(res < x); return res; } -static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { uint64_t res = x - y; res &= -(res <= x); return res; @@ -225,7 +245,8 @@ static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { // Clang also defines "__GNUC__". -static inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) { +static inline uint16_t // +wuffs_base__u16__byte_swapped(uint16_t x) { #if defined(__GNUC__) return __builtin_bswap16(x); #else @@ -233,7 +254,8 @@ static inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) { #endif } -static inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) { +static inline uint32_t // +wuffs_base__u32__byte_swapped(uint32_t x) { #if defined(__GNUC__) return __builtin_bswap32(x); #else @@ -243,7 +265,8 @@ static inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) { #endif } -static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { +static inline uint64_t // +wuffs_base__u64__byte_swapped(uint64_t x) { #if defined(__GNUC__) return __builtin_bswap64(x); #else @@ -336,37 +359,38 @@ typedef struct wuffs_base__range_ii_u32__struct { } wuffs_base__range_ii_u32; -static inline bool wuffs_base__range_ii_u32__is_empty( - wuffs_base__range_ii_u32* r) { +static inline bool // +wuffs_base__range_ii_u32__is_empty(wuffs_base__range_ii_u32* r) { return r->min_incl > r->max_incl; } -static inline bool wuffs_base__range_ii_u32__equals( - wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline bool // +wuffs_base__range_ii_u32__equals(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) || (wuffs_base__range_ii_u32__is_empty(r) && wuffs_base__range_ii_u32__is_empty(&s)); } -static inline bool wuffs_base__range_ii_u32__contains( - wuffs_base__range_ii_u32* r, - uint32_t x) { +static inline bool // +wuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) { return (r->min_incl <= x) && (x <= r->max_incl); } -static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersect( - wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline // + wuffs_base__range_ii_u32 + wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { wuffs_base__range_ii_u32 t; t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl); return t; } -static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite( - wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline // + wuffs_base__range_ii_u32 + wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { if (wuffs_base__range_ii_u32__is_empty(r)) { return s; } @@ -381,25 +405,28 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite( #ifdef __cplusplus -inline bool wuffs_base__range_ii_u32::is_empty() { +inline bool // +wuffs_base__range_ii_u32::is_empty() { return wuffs_base__range_ii_u32__is_empty(this); } -inline bool wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) { +inline bool // +wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) { return wuffs_base__range_ii_u32__equals(this, s); } -inline bool wuffs_base__range_ii_u32::contains(uint32_t x) { +inline bool // +wuffs_base__range_ii_u32::contains(uint32_t x) { return wuffs_base__range_ii_u32__contains(this, x); } -inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::intersect( - wuffs_base__range_ii_u32 s) { +inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) { return wuffs_base__range_ii_u32__intersect(this, s); } -inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::unite( - wuffs_base__range_ii_u32 s) { +inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) { return wuffs_base__range_ii_u32__unite(this, s); } @@ -424,37 +451,36 @@ typedef struct wuffs_base__range_ie_u32__struct { } wuffs_base__range_ie_u32; -static inline bool wuffs_base__range_ie_u32__is_empty( - wuffs_base__range_ie_u32* r) { +static inline bool // +wuffs_base__range_ie_u32__is_empty(wuffs_base__range_ie_u32* r) { return r->min_incl >= r->max_excl; } -static inline bool wuffs_base__range_ie_u32__equals( - wuffs_base__range_ie_u32* r, - wuffs_base__range_ie_u32 s) { +static inline bool // +wuffs_base__range_ie_u32__equals(wuffs_base__range_ie_u32* r, + wuffs_base__range_ie_u32 s) { return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) || (wuffs_base__range_ie_u32__is_empty(r) && wuffs_base__range_ie_u32__is_empty(&s)); } -static inline bool wuffs_base__range_ie_u32__contains( - wuffs_base__range_ie_u32* r, - uint32_t x) { +static inline bool // +wuffs_base__range_ie_u32__contains(wuffs_base__range_ie_u32* r, uint32_t x) { return (r->min_incl <= x) && (x < r->max_excl); } -static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersect( - wuffs_base__range_ie_u32* r, - wuffs_base__range_ie_u32 s) { +static inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32__intersect(wuffs_base__range_ie_u32* r, + wuffs_base__range_ie_u32 s) { wuffs_base__range_ie_u32 t; t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl); return t; } -static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite( - wuffs_base__range_ie_u32* r, - wuffs_base__range_ie_u32 s) { +static inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32__unite(wuffs_base__range_ie_u32* r, + wuffs_base__range_ie_u32 s) { if (wuffs_base__range_ie_u32__is_empty(r)) { return s; } @@ -467,36 +493,40 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite( return t; } -static inline uint32_t wuffs_base__range_ie_u32__length( - wuffs_base__range_ie_u32* r) { +static inline uint32_t // +wuffs_base__range_ie_u32__length(wuffs_base__range_ie_u32* r) { return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl); } #ifdef __cplusplus -inline bool wuffs_base__range_ie_u32::is_empty() { +inline bool // +wuffs_base__range_ie_u32::is_empty() { return wuffs_base__range_ie_u32__is_empty(this); } -inline bool wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) { +inline bool // +wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) { return wuffs_base__range_ie_u32__equals(this, s); } -inline bool wuffs_base__range_ie_u32::contains(uint32_t x) { +inline bool // +wuffs_base__range_ie_u32::contains(uint32_t x) { return wuffs_base__range_ie_u32__contains(this, x); } -inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::intersect( - wuffs_base__range_ie_u32 s) { +inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) { return wuffs_base__range_ie_u32__intersect(this, s); } -inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::unite( - wuffs_base__range_ie_u32 s) { +inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) { return wuffs_base__range_ie_u32__unite(this, s); } -inline uint32_t wuffs_base__range_ie_u32::length() { +inline uint32_t // +wuffs_base__range_ie_u32::length() { return wuffs_base__range_ie_u32__length(this); } @@ -520,37 +550,36 @@ typedef struct wuffs_base__range_ii_u64__struct { } wuffs_base__range_ii_u64; -static inline bool wuffs_base__range_ii_u64__is_empty( - wuffs_base__range_ii_u64* r) { +static inline bool // +wuffs_base__range_ii_u64__is_empty(wuffs_base__range_ii_u64* r) { return r->min_incl > r->max_incl; } -static inline bool wuffs_base__range_ii_u64__equals( - wuffs_base__range_ii_u64* r, - wuffs_base__range_ii_u64 s) { +static inline bool // +wuffs_base__range_ii_u64__equals(wuffs_base__range_ii_u64* r, + wuffs_base__range_ii_u64 s) { return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) || (wuffs_base__range_ii_u64__is_empty(r) && wuffs_base__range_ii_u64__is_empty(&s)); } -static inline bool wuffs_base__range_ii_u64__contains( - wuffs_base__range_ii_u64* r, - uint64_t x) { +static inline bool // +wuffs_base__range_ii_u64__contains(wuffs_base__range_ii_u64* r, uint64_t x) { return (r->min_incl <= x) && (x <= r->max_incl); } -static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersect( - wuffs_base__range_ii_u64* r, - wuffs_base__range_ii_u64 s) { +static inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64__intersect(wuffs_base__range_ii_u64* r, + wuffs_base__range_ii_u64 s) { wuffs_base__range_ii_u64 t; t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl); t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl); return t; } -static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite( - wuffs_base__range_ii_u64* r, - wuffs_base__range_ii_u64 s) { +static inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64__unite(wuffs_base__range_ii_u64* r, + wuffs_base__range_ii_u64 s) { if (wuffs_base__range_ii_u64__is_empty(r)) { return s; } @@ -565,25 +594,28 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite( #ifdef __cplusplus -inline bool wuffs_base__range_ii_u64::is_empty() { +inline bool // +wuffs_base__range_ii_u64::is_empty() { return wuffs_base__range_ii_u64__is_empty(this); } -inline bool wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) { +inline bool // +wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) { return wuffs_base__range_ii_u64__equals(this, s); } -inline bool wuffs_base__range_ii_u64::contains(uint64_t x) { +inline bool // +wuffs_base__range_ii_u64::contains(uint64_t x) { return wuffs_base__range_ii_u64__contains(this, x); } -inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::intersect( - wuffs_base__range_ii_u64 s) { +inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64::intersect(wuffs_base__range_ii_u64 s) { return wuffs_base__range_ii_u64__intersect(this, s); } -inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::unite( - wuffs_base__range_ii_u64 s) { +inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) { return wuffs_base__range_ii_u64__unite(this, s); } @@ -608,37 +640,36 @@ typedef struct wuffs_base__range_ie_u64__struct { } wuffs_base__range_ie_u64; -static inline bool wuffs_base__range_ie_u64__is_empty( - wuffs_base__range_ie_u64* r) { +static inline bool // +wuffs_base__range_ie_u64__is_empty(wuffs_base__range_ie_u64* r) { return r->min_incl >= r->max_excl; } -static inline bool wuffs_base__range_ie_u64__equals( - wuffs_base__range_ie_u64* r, - wuffs_base__range_ie_u64 s) { +static inline bool // +wuffs_base__range_ie_u64__equals(wuffs_base__range_ie_u64* r, + wuffs_base__range_ie_u64 s) { return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) || (wuffs_base__range_ie_u64__is_empty(r) && wuffs_base__range_ie_u64__is_empty(&s)); } -static inline bool wuffs_base__range_ie_u64__contains( - wuffs_base__range_ie_u64* r, - uint64_t x) { +static inline bool // +wuffs_base__range_ie_u64__contains(wuffs_base__range_ie_u64* r, uint64_t x) { return (r->min_incl <= x) && (x < r->max_excl); } -static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersect( - wuffs_base__range_ie_u64* r, - wuffs_base__range_ie_u64 s) { +static inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64__intersect(wuffs_base__range_ie_u64* r, + wuffs_base__range_ie_u64 s) { wuffs_base__range_ie_u64 t; t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl); t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl); return t; } -static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite( - wuffs_base__range_ie_u64* r, - wuffs_base__range_ie_u64 s) { +static inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64__unite(wuffs_base__range_ie_u64* r, + wuffs_base__range_ie_u64 s) { if (wuffs_base__range_ie_u64__is_empty(r)) { return s; } @@ -651,36 +682,40 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite( return t; } -static inline uint64_t wuffs_base__range_ie_u64__length( - wuffs_base__range_ie_u64* r) { +static inline uint64_t // +wuffs_base__range_ie_u64__length(wuffs_base__range_ie_u64* r) { return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl); } #ifdef __cplusplus -inline bool wuffs_base__range_ie_u64::is_empty() { +inline bool // +wuffs_base__range_ie_u64::is_empty() { return wuffs_base__range_ie_u64__is_empty(this); } -inline bool wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) { +inline bool // +wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) { return wuffs_base__range_ie_u64__equals(this, s); } -inline bool wuffs_base__range_ie_u64::contains(uint64_t x) { +inline bool // +wuffs_base__range_ie_u64::contains(uint64_t x) { return wuffs_base__range_ie_u64__contains(this, x); } -inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::intersect( - wuffs_base__range_ie_u64 s) { +inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) { return wuffs_base__range_ie_u64__intersect(this, s); } -inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::unite( - wuffs_base__range_ie_u64 s) { +inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) { return wuffs_base__range_ie_u64__unite(this, s); } -inline uint64_t wuffs_base__range_ie_u64::length() { +inline uint64_t // +wuffs_base__range_ie_u64::length() { return wuffs_base__range_ie_u64__length(this); } @@ -715,29 +750,31 @@ typedef struct wuffs_base__rect_ii_u32__struct { } wuffs_base__rect_ii_u32; -static inline bool wuffs_base__rect_ii_u32__is_empty( - wuffs_base__rect_ii_u32* r) { +static inline bool // +wuffs_base__rect_ii_u32__is_empty(wuffs_base__rect_ii_u32* r) { return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y); } -static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r, - wuffs_base__rect_ii_u32 s) { +static inline bool // +wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r, + wuffs_base__rect_ii_u32 s) { return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y && r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) || (wuffs_base__rect_ii_u32__is_empty(r) && wuffs_base__rect_ii_u32__is_empty(&s)); } -static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r, - uint32_t x, - uint32_t y) { +static inline bool // +wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r, + uint32_t x, + uint32_t y) { return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) && (y <= r->max_incl_y); } -static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect( - wuffs_base__rect_ii_u32* r, - wuffs_base__rect_ii_u32 s) { +static inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32__intersect(wuffs_base__rect_ii_u32* r, + wuffs_base__rect_ii_u32 s) { wuffs_base__rect_ii_u32 t; t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x); t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y); @@ -746,9 +783,9 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect( return t; } -static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite( - wuffs_base__rect_ii_u32* r, - wuffs_base__rect_ii_u32 s) { +static inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32__unite(wuffs_base__rect_ii_u32* r, + wuffs_base__rect_ii_u32 s) { if (wuffs_base__rect_ii_u32__is_empty(r)) { return s; } @@ -765,25 +802,28 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite( #ifdef __cplusplus -inline bool wuffs_base__rect_ii_u32::is_empty() { +inline bool // +wuffs_base__rect_ii_u32::is_empty() { return wuffs_base__rect_ii_u32__is_empty(this); } -inline bool wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) { +inline bool // +wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) { return wuffs_base__rect_ii_u32__equals(this, s); } -inline bool wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) { +inline bool // +wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) { return wuffs_base__rect_ii_u32__contains(this, x, y); } -inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::intersect( - wuffs_base__rect_ii_u32 s) { +inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) { return wuffs_base__rect_ii_u32__intersect(this, s); } -inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::unite( - wuffs_base__rect_ii_u32 s) { +inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) { return wuffs_base__rect_ii_u32__unite(this, s); } @@ -821,29 +861,31 @@ typedef struct wuffs_base__rect_ie_u32__struct { } wuffs_base__rect_ie_u32; -static inline bool wuffs_base__rect_ie_u32__is_empty( - wuffs_base__rect_ie_u32* r) { +static inline bool // +wuffs_base__rect_ie_u32__is_empty(wuffs_base__rect_ie_u32* r) { return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y); } -static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r, - wuffs_base__rect_ie_u32 s) { +static inline bool // +wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r, + wuffs_base__rect_ie_u32 s) { return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y && r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) || (wuffs_base__rect_ie_u32__is_empty(r) && wuffs_base__rect_ie_u32__is_empty(&s)); } -static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r, - uint32_t x, - uint32_t y) { +static inline bool // +wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r, + uint32_t x, + uint32_t y) { return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) && (y < r->max_excl_y); } -static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersect( - wuffs_base__rect_ie_u32* r, - wuffs_base__rect_ie_u32 s) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32__intersect(wuffs_base__rect_ie_u32* r, + wuffs_base__rect_ie_u32 s) { wuffs_base__rect_ie_u32 t; t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x); t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y); @@ -852,9 +894,9 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersect( return t; } -static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite( - wuffs_base__rect_ie_u32* r, - wuffs_base__rect_ie_u32 s) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32__unite(wuffs_base__rect_ie_u32* r, + wuffs_base__rect_ie_u32 s) { if (wuffs_base__rect_ie_u32__is_empty(r)) { return s; } @@ -869,45 +911,50 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite( return t; } -static inline uint32_t wuffs_base__rect_ie_u32__width( - wuffs_base__rect_ie_u32* r) { +static inline uint32_t // +wuffs_base__rect_ie_u32__width(wuffs_base__rect_ie_u32* r) { return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x); } -static inline uint32_t wuffs_base__rect_ie_u32__height( - wuffs_base__rect_ie_u32* r) { +static inline uint32_t // +wuffs_base__rect_ie_u32__height(wuffs_base__rect_ie_u32* r) { return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y); } #ifdef __cplusplus -inline bool wuffs_base__rect_ie_u32::is_empty() { +inline bool // +wuffs_base__rect_ie_u32::is_empty() { return wuffs_base__rect_ie_u32__is_empty(this); } -inline bool wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) { +inline bool // +wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) { return wuffs_base__rect_ie_u32__equals(this, s); } -inline bool wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) { +inline bool // +wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) { return wuffs_base__rect_ie_u32__contains(this, x, y); } -inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::intersect( - wuffs_base__rect_ie_u32 s) { +inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) { return wuffs_base__rect_ie_u32__intersect(this, s); } -inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::unite( - wuffs_base__rect_ie_u32 s) { +inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) { return wuffs_base__rect_ie_u32__unite(this, s); } -inline uint32_t wuffs_base__rect_ie_u32::width() { +inline uint32_t // +wuffs_base__rect_ie_u32::width() { return wuffs_base__rect_ie_u32__width(this); } -inline uint32_t wuffs_base__rect_ie_u32::height() { +inline uint32_t // +wuffs_base__rect_ie_u32::height() { return wuffs_base__rect_ie_u32__height(this); } @@ -962,7 +1009,8 @@ typedef struct wuffs_base__io_buffer__struct { // wuffs_base__io_buffer__compact moves any written but unread bytes to the // start of the buffer. -static inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { +static inline void // +wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { if (!buf || (buf->ri == 0)) { return; } @@ -974,15 +1022,15 @@ static inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { buf->ri = 0; } -static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( - wuffs_base__io_buffer* buf) { +static inline wuffs_base__io_reader // +wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); ret.private_impl.buf = buf; return ret; } -static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( - wuffs_base__io_buffer* buf) { +static inline wuffs_base__io_writer // +wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); ret.private_impl.buf = buf; return ret; @@ -990,15 +1038,18 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( #ifdef __cplusplus -inline void wuffs_base__io_buffer__struct::compact() { +inline void // +wuffs_base__io_buffer__struct::compact() { wuffs_base__io_buffer__compact(this); } -inline wuffs_base__io_reader wuffs_base__io_buffer__struct::reader() { +inline wuffs_base__io_reader // +wuffs_base__io_buffer__struct::reader() { return wuffs_base__io_buffer__reader(this); } -inline wuffs_base__io_writer wuffs_base__io_buffer__struct::writer() { +inline wuffs_base__io_writer // +wuffs_base__io_buffer__struct::writer() { return wuffs_base__io_buffer__writer(this); } @@ -1164,20 +1215,20 @@ typedef uint32_t wuffs_base__pixel_format; #define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888) #define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888) -static inline bool wuffs_base__pixel_format__is_valid( - wuffs_base__pixel_format f) { +static inline bool // +wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) { return f != 0; } -static inline bool wuffs_base__pixel_format__is_indexed( - wuffs_base__pixel_format f) { +static inline bool // +wuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) { return ((f >> 16) & 0x0F) != 0; } #define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 -static inline uint32_t wuffs_base__pixel_format__num_planes( - wuffs_base__pixel_format f) { +static inline uint32_t // +wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) { return f ? (((f >> 20) & 0x03) + 1) : 0; } @@ -1237,30 +1288,30 @@ typedef uint32_t wuffs_base__pixel_subsampling; #define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \ ((wuffs_base__pixel_subsampling)0x212100) -static inline uint32_t wuffs_base__pixel_subsampling__bias_x( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__bias_x(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 6; return (s >> shift) & 0x03; } -static inline uint32_t wuffs_base__pixel_subsampling__shift_x( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__shift_x(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 4; return (s >> shift) & 0x03; } -static inline uint32_t wuffs_base__pixel_subsampling__bias_y( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 2; return (s >> shift) & 0x03; } -static inline uint32_t wuffs_base__pixel_subsampling__shift_y( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__shift_y(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 0; return (s >> shift) & 0x03; } @@ -1301,14 +1352,14 @@ typedef struct { } wuffs_base__image_config; // TODO: Should this function return bool? An error type? -static inline void wuffs_base__image_config__initialize( - wuffs_base__image_config* c, - wuffs_base__pixel_format pixfmt, - wuffs_base__pixel_subsampling pixsub, - uint32_t width, - uint32_t height, - uint32_t num_loops, - bool first_frame_is_opaque) { +static inline void // +wuffs_base__image_config__initialize(wuffs_base__image_config* c, + wuffs_base__pixel_format pixfmt, + wuffs_base__pixel_subsampling pixsub, + uint32_t width, + uint32_t height, + uint32_t num_loops, + bool first_frame_is_opaque) { if (!c) { return; } @@ -1328,30 +1379,30 @@ static inline void wuffs_base__image_config__initialize( *c = ((wuffs_base__image_config){}); } -static inline void wuffs_base__image_config__invalidate( - wuffs_base__image_config* c) { +static inline void // +wuffs_base__image_config__invalidate(wuffs_base__image_config* c) { if (c) { *c = ((wuffs_base__image_config){}); } } -static inline bool wuffs_base__image_config__is_valid( - wuffs_base__image_config* c) { +static inline bool // +wuffs_base__image_config__is_valid(wuffs_base__image_config* c) { return c && c->private_impl.pixfmt; } -static inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format( - wuffs_base__image_config* c) { +static inline wuffs_base__pixel_format // +wuffs_base__image_config__pixel_format(wuffs_base__image_config* c) { return c ? c->private_impl.pixfmt : 0; } -static inline wuffs_base__pixel_subsampling +static inline wuffs_base__pixel_subsampling // wuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) { return c ? c->private_impl.pixsub : 0; } -static inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds( - wuffs_base__image_config* c) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__image_config__bounds(wuffs_base__image_config* c) { return c ? ((wuffs_base__rect_ie_u32){ .min_incl_x = 0, .min_incl_y = 0, @@ -1361,31 +1412,31 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds( : ((wuffs_base__rect_ie_u32){}); } -static inline uint32_t wuffs_base__image_config__width( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__width(wuffs_base__image_config* c) { return c ? c->private_impl.width : 0; } -static inline uint32_t wuffs_base__image_config__height( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__height(wuffs_base__image_config* c) { return c ? c->private_impl.height : 0; } -static inline uint32_t wuffs_base__image_config__num_loops( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__num_loops(wuffs_base__image_config* c) { return c ? c->private_impl.num_loops : 0; } -static inline uint32_t wuffs_base__image_config__first_frame_is_opaque( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) { return c ? c->private_impl.first_frame_is_opaque : false; } // TODO: this is the right API for planar (not packed) pixbufs? Should it allow // decoding into a color model different from the format's intrinsic one? For // example, decoding a JPEG image straight to RGBA instead of to YCbCr? -static inline size_t wuffs_base__image_config__pixbuf_size( - wuffs_base__image_config* c) { +static inline size_t // +wuffs_base__image_config__pixbuf_size(wuffs_base__image_config* c) { if (c) { uint64_t wh = ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); @@ -1397,55 +1448,64 @@ static inline size_t wuffs_base__image_config__pixbuf_size( #ifdef __cplusplus -inline void wuffs_base__image_config::initialize( - wuffs_base__pixel_format pixfmt, - wuffs_base__pixel_subsampling pixsub, - uint32_t width, - uint32_t height, - uint32_t num_loops, - bool first_frame_is_opaque) { +inline void // +wuffs_base__image_config::initialize(wuffs_base__pixel_format pixfmt, + wuffs_base__pixel_subsampling pixsub, + uint32_t width, + uint32_t height, + uint32_t num_loops, + bool first_frame_is_opaque) { wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height, num_loops, first_frame_is_opaque); } -inline void wuffs_base__image_config::invalidate() { +inline void // +wuffs_base__image_config::invalidate() { wuffs_base__image_config__invalidate(this); } -inline bool wuffs_base__image_config::is_valid() { +inline bool // +wuffs_base__image_config::is_valid() { return wuffs_base__image_config__is_valid(this); } -inline wuffs_base__pixel_format wuffs_base__image_config::pixel_format() { +inline wuffs_base__pixel_format // +wuffs_base__image_config::pixel_format() { return wuffs_base__image_config__pixel_format(this); } -inline wuffs_base__pixel_subsampling +inline wuffs_base__pixel_subsampling // wuffs_base__image_config::pixel_subsampling() { return wuffs_base__image_config__pixel_subsampling(this); } -inline wuffs_base__rect_ie_u32 wuffs_base__image_config::bounds() { +inline wuffs_base__rect_ie_u32 // +wuffs_base__image_config::bounds() { return wuffs_base__image_config__bounds(this); } -inline uint32_t wuffs_base__image_config::width() { +inline uint32_t // +wuffs_base__image_config::width() { return wuffs_base__image_config__width(this); } -inline uint32_t wuffs_base__image_config::height() { +inline uint32_t // +wuffs_base__image_config::height() { return wuffs_base__image_config__height(this); } -inline uint32_t wuffs_base__image_config::num_loops() { +inline uint32_t // +wuffs_base__image_config::num_loops() { return wuffs_base__image_config__num_loops(this); } -inline uint32_t wuffs_base__image_config::first_frame_is_opaque() { +inline uint32_t // +wuffs_base__image_config::first_frame_is_opaque() { return wuffs_base__image_config__first_frame_is_opaque(this); } -inline size_t wuffs_base__image_config::pixbuf_size() { +inline size_t // +wuffs_base__image_config::pixbuf_size() { return wuffs_base__image_config__pixbuf_size(this); } @@ -1511,10 +1571,10 @@ typedef struct { } wuffs_base__image_buffer; -static inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf( - wuffs_base__image_buffer* b, - wuffs_base__image_config config, - wuffs_base__pixel_buffer pixbuf) { +static inline wuffs_base__status // +wuffs_base__image_buffer__set_from_pixbuf(wuffs_base__image_buffer* b, + wuffs_base__image_config config, + wuffs_base__pixel_buffer pixbuf) { if (!b) { return WUFFS_BASE__ERROR_BAD_RECEIVER; } @@ -1524,10 +1584,10 @@ static inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf( return WUFFS_BASE__STATUS_OK; } -static inline wuffs_base__status wuffs_base__image_buffer__set_from_slice( - wuffs_base__image_buffer* b, - wuffs_base__image_config config, - wuffs_base__slice_u8 pixbuf_memory) { +static inline wuffs_base__status // +wuffs_base__image_buffer__set_from_slice(wuffs_base__image_buffer* b, + wuffs_base__image_config config, + wuffs_base__slice_u8 pixbuf_memory) { if (!b) { return WUFFS_BASE__ERROR_BAD_RECEIVER; } @@ -1548,13 +1608,13 @@ static inline wuffs_base__status wuffs_base__image_buffer__set_from_slice( } // The palette argument is ignored unless its length is exactly 1024. -static inline void wuffs_base__image_buffer__update( - wuffs_base__image_buffer* b, - wuffs_base__rect_ie_u32 dirty_rect, - wuffs_base__flicks duration, - bool blend, - wuffs_base__animation_disposal disposal, - wuffs_base__slice_u8 palette) { +static inline void // +wuffs_base__image_buffer__update(wuffs_base__image_buffer* b, + wuffs_base__rect_ie_u32 dirty_rect, + wuffs_base__flicks duration, + bool blend, + wuffs_base__animation_disposal disposal, + wuffs_base__slice_u8 palette) { if (!b) { return; } @@ -1576,38 +1636,38 @@ static inline void wuffs_base__image_buffer__update( } // wuffs_base__image_config returns the overall configuration for this frame. -static inline wuffs_base__image_config* wuffs_base__image_buffer__image_config( - wuffs_base__image_buffer* b) { +static inline wuffs_base__image_config* // +wuffs_base__image_buffer__image_config(wuffs_base__image_buffer* b) { return b ? &b->private_impl.config : NULL; } -static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__bounds( - wuffs_base__image_buffer* b) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer__bounds(wuffs_base__image_buffer* b) { return b ? wuffs_base__image_config__bounds(&b->private_impl.config) : ((wuffs_base__rect_ie_u32){}); } -static inline uint32_t wuffs_base__image_buffer__width( - wuffs_base__image_buffer* b) { +static inline uint32_t // +wuffs_base__image_buffer__width(wuffs_base__image_buffer* b) { return b ? wuffs_base__image_config__width(&b->private_impl.config) : 0; } -static inline uint32_t wuffs_base__image_buffer__height( - wuffs_base__image_buffer* b) { +static inline uint32_t // +wuffs_base__image_buffer__height(wuffs_base__image_buffer* b) { return b ? wuffs_base__image_config__height(&b->private_impl.config) : 0; } // wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of // this frame's pixels differs from the previous frame. -static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect( - wuffs_base__image_buffer* b) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer__dirty_rect(wuffs_base__image_buffer* b) { return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){}); } // wuffs_base__image_buffer__duration returns the amount of time to display // this frame. Zero means to display forever - a still (non-animated) image. -static inline wuffs_base__flicks wuffs_base__image_buffer__duration( - wuffs_base__image_buffer* b) { +static inline wuffs_base__flicks // +wuffs_base__image_buffer__duration(wuffs_base__image_buffer* b) { return b ? b->private_impl.duration : 0; } @@ -1616,38 +1676,37 @@ static inline wuffs_base__flicks wuffs_base__image_buffer__duration( // // In Porter-Duff compositing operator terminology, false means "src" and true // means "src over dst". -static inline bool wuffs_base__image_buffer__blend( - wuffs_base__image_buffer* b) { +static inline bool // +wuffs_base__image_buffer__blend(wuffs_base__image_buffer* b) { return b && b->private_impl.blend; } // wuffs_base__image_buffer__disposal returns, for an animated image, how to // dispose of this frame after displaying it. -static inline wuffs_base__animation_disposal wuffs_base__image_buffer__disposal( - wuffs_base__image_buffer* b) { +static inline wuffs_base__animation_disposal // +wuffs_base__image_buffer__disposal(wuffs_base__image_buffer* b) { return b ? b->private_impl.disposal : 0; } // wuffs_base__image_buffer__palette_changed returns whether this frame's // palette differs from the previous frame. It is conservative and may return // false positives (but never false negatives). -static inline bool wuffs_base__image_buffer__palette_changed( - wuffs_base__image_buffer* b) { +static inline bool // +wuffs_base__image_buffer__palette_changed(wuffs_base__image_buffer* b) { return b && b->private_impl.palette_changed; } // wuffs_base__image_buffer__palette returns the palette that the pixel data // can index. The backing array is inside b and has length 1024. -static inline wuffs_base__slice_u8 wuffs_base__image_buffer__palette( - wuffs_base__image_buffer* b) { +static inline wuffs_base__slice_u8 // +wuffs_base__image_buffer__palette(wuffs_base__image_buffer* b) { return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette, .len = 1024}) : ((wuffs_base__slice_u8){}); } -static inline wuffs_base__table_u8 wuffs_base__image_buffer__plane( - wuffs_base__image_buffer* b, - uint32_t p) { +static inline wuffs_base__table_u8 // +wuffs_base__image_buffer__plane(wuffs_base__image_buffer* b, uint32_t p) { return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) ? b->private_impl.pixbuf.planes[p] : ((wuffs_base__table_u8){}); @@ -1655,69 +1714,80 @@ static inline wuffs_base__table_u8 wuffs_base__image_buffer__plane( #ifdef __cplusplus -inline wuffs_base__status wuffs_base__image_buffer::set_from_pixbuf( - wuffs_base__image_config config, - wuffs_base__pixel_buffer pixbuf) { +inline wuffs_base__status // +wuffs_base__image_buffer::set_from_pixbuf(wuffs_base__image_config config, + wuffs_base__pixel_buffer pixbuf) { return wuffs_base__image_buffer__set_from_pixbuf(this, config, pixbuf); } -inline wuffs_base__status wuffs_base__image_buffer::set_from_slice( - wuffs_base__image_config config, - wuffs_base__slice_u8 pixbuf_memory) { +inline wuffs_base__status // +wuffs_base__image_buffer::set_from_slice(wuffs_base__image_config config, + wuffs_base__slice_u8 pixbuf_memory) { return wuffs_base__image_buffer__set_from_slice(this, config, pixbuf_memory); } -inline void wuffs_base__image_buffer::update( - wuffs_base__rect_ie_u32 dirty_rect, - wuffs_base__flicks duration, - bool blend, - wuffs_base__animation_disposal disposal, - wuffs_base__slice_u8 palette) { +inline void // +wuffs_base__image_buffer::update(wuffs_base__rect_ie_u32 dirty_rect, + wuffs_base__flicks duration, + bool blend, + wuffs_base__animation_disposal disposal, + wuffs_base__slice_u8 palette) { wuffs_base__image_buffer__update(this, dirty_rect, duration, blend, disposal, palette); } -inline wuffs_base__image_config* wuffs_base__image_buffer::image_config() { +inline wuffs_base__image_config* // +wuffs_base__image_buffer::image_config() { return wuffs_base__image_buffer__image_config(this); } -inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::bounds() { +inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer::bounds() { return wuffs_base__image_buffer__bounds(this); } -inline uint32_t wuffs_base__image_buffer::width() { +inline uint32_t // +wuffs_base__image_buffer::width() { return wuffs_base__image_buffer__width(this); } -inline uint32_t wuffs_base__image_buffer::height() { +inline uint32_t // +wuffs_base__image_buffer::height() { return wuffs_base__image_buffer__height(this); } -inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::dirty_rect() { +inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer::dirty_rect() { return wuffs_base__image_buffer__dirty_rect(this); } -inline wuffs_base__flicks wuffs_base__image_buffer::duration() { +inline wuffs_base__flicks // +wuffs_base__image_buffer::duration() { return wuffs_base__image_buffer__duration(this); } -inline bool wuffs_base__image_buffer::blend() { +inline bool // +wuffs_base__image_buffer::blend() { return wuffs_base__image_buffer__blend(this); } -inline wuffs_base__animation_disposal wuffs_base__image_buffer::disposal() { +inline wuffs_base__animation_disposal // +wuffs_base__image_buffer::disposal() { return wuffs_base__image_buffer__disposal(this); } -inline bool wuffs_base__image_buffer::palette_changed() { +inline bool // +wuffs_base__image_buffer::palette_changed() { return wuffs_base__image_buffer__palette_changed(this); } -inline wuffs_base__slice_u8 wuffs_base__image_buffer::palette() { +inline wuffs_base__slice_u8 // +wuffs_base__image_buffer::palette() { return wuffs_base__image_buffer__palette(this); } -inline wuffs_base__table_u8 wuffs_base__image_buffer::plane(uint32_t p) { +inline wuffs_base__table_u8 // +wuffs_base__image_buffer::plane(uint32_t p) { return wuffs_base__image_buffer__plane(this, p); } diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 9e396baf..fab43c0a 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -22,52 +22,52 @@ const basePublicH = "" + "d in the \"ALLOW STATIC\n// IMPLEMENTATION\" section of\n// https://raw.githubusercontent.com/nothings/stb/master/docs/stb_howto.txt\n#ifdef WUFFS_CONFIG__STATIC_FUNCTIONS\n#define WUFFS_BASE__MAYBE_STATIC static\n#else\n#define WUFFS_BASE__MAYBE_STATIC\n#endif\n\n// wuffs_base__empty_struct is used when a Wuffs function returns an empty\n// struct. In C, if a function f returns void, you can't say \"x = f()\", but in\n// Wuffs, if a function g returns empty, you can say \"y = g()\".\ntypedef struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct " + "is always 1.\n uint8_t private_impl;\n} wuffs_base__empty_struct;\n\n// wuffs_base__utility is a placeholder receiver type. It enables what Java\n// calls static methods, as opposed to regular methods.\ntypedef struct {\n // private_impl is a placeholder field. It isn't explicitly used, except that\n // without it, the sizeof a struct with no fields can differ across C/C++\n // compilers, and it is undefined behavior in C99. For example, gcc says that\n // the sizeof an empty struct is 0, and g++ says that it is 1. This leads to\n // ABI incompatibility if a Wuffs .c file is processed by one compiler and\n // its .h file with another compiler.\n //\n // Instead, we explicitly insert an otherwise unused field, so that the\n // sizeof this struct is always 1.\n uint8_t private_impl;\n} wuffs_base__utility;\n\n" + "" + - "// --------\n\n// A status code is either zero (OK), positive (a recoverable suspension or\n// pause in processing) or negative (a non-recoverable error). Its bits:\n// - bit 31 (the sign bit) indicates unrecoverable-ness: an error.\n// - bits 30 .. 24 are a package-namespaced numeric code\n// - bits 23 .. 21 are reserved.\n// - bits 20 .. 0 are the packageid (a namespace) as a base38 value.\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__status__is_error instead.\ntypedef int32_t wuffs_base__status;\n\n// !! INSERT wuffs_base__status names.\n\nstatic inline bool wuffs_base__status__is_error(wuffs_base__status s) {\n return s < 0;\n}\n\nstatic inline bool wuffs_base__status__is_ok(wuffs_base__status s) {\n return s == 0;\n}\n\nstatic inline bool wuffs_base__status__is_suspension(wuffs_base__status s) {\n return s > 0;\n}\n\nconst char* wuffs_base__status__string(wuffs_base__status s);\n\n" + + "// --------\n\n// A status code is either zero (OK), positive (a recoverable suspension or\n// pause in processing) or negative (a non-recoverable error). Its bits:\n// - bit 31 (the sign bit) indicates unrecoverable-ness: an error.\n// - bits 30 .. 24 are a package-namespaced numeric code\n// - bits 23 .. 21 are reserved.\n// - bits 20 .. 0 are the packageid (a namespace) as a base38 value.\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__status__is_error instead.\ntypedef int32_t wuffs_base__status;\n\n// !! INSERT wuffs_base__status names.\n\nstatic inline bool //\nwuffs_base__status__is_error(wuffs_base__status s) {\n return s < 0;\n}\n\nstatic inline bool //\nwuffs_base__status__is_ok(wuffs_base__status s) {\n return s == 0;\n}\n\nstatic inline bool //\nwuffs_base__status__is_suspension(wuffs_base__status s) {\n return s > 0;\n}\n\nconst char* //\nwuffs_base__status__string(wuffs_base__status s);\n\n" + "" + "// --------\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef int64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000)\n#define WUFFS_BASE__FLICKS_PER_MILLISECOND ((uint64_t)705600)\n\n" + "" + - "// ---------------- Numeric Types\n\nstatic inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) {\n return x > y ? x : y;\n}\n\n" + + "// ---------------- Numeric Types\n\nstatic inline uint8_t //\nwuffs_base__u8__min(uint8_t x, uint8_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__max(uint8_t x, uint8_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__min(uint16_t x, uint16_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__max(uint16_t x, uint16_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__min(uint32_t x, uint32_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__max(uint32_t x, uint32_t y) {\n return x > y ? x : y;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__min(uint64_t x, uint64_t y) {\n return x < y ? x : y;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__max(uint64_t x, uint64_t y) {\n return x > y ? x : y;\n}\n\n" + "" + - "// --------\n\n// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms\n// are per https://locklessinc.com/articles/sat_arithmetic/\n//\n// It is important that the underlying types are unsigned integers, as signed\n// integer arithmetic overflow is undefined behavior in C.\n\nstatic inline uint8_t wuffs_base__u8__sat_add(uint8_t x, uint8_t y) {\n uint8_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint8_t wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {\n uint8_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint16_t wuffs_base__u16__sat_add(uint16_t x, uint16_t y) {\n uint16_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint16_t wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {\n uint16_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {\n uint32_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint32_t wuffs_base__u32__sat_sub(uint32_t x" + - ", uint32_t y) {\n uint32_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n uint64_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n uint64_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\n" + + "// --------\n\n// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms\n// are per https://locklessinc.com/articles/sat_arithmetic/\n//\n// It is important that the underlying types are unsigned integers, as signed\n// integer arithmetic overflow is undefined behavior in C.\n\nstatic inline uint8_t //\nwuffs_base__u8__sat_add(uint8_t x, uint8_t y) {\n uint8_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint8_t //\nwuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {\n uint8_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__sat_add(uint16_t x, uint16_t y) {\n uint16_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint16_t //\nwuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {\n uint16_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__sat_add(uint32_t x, uint32_t y) {\n uint32_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint32_t //\nwuffs_base_" + + "_u32__sat_sub(uint32_t x, uint32_t y) {\n uint32_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n uint64_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n uint64_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\n" + "" + - "// --------\n\n// Clang also defines \"__GNUC__\".\n\nstatic inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap16(x);\n#else\n return (x >> 8) | (x << 8);\n#endif\n}\n\nstatic inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap32(x);\n#else\n static const uint32_t mask8 = 0x00FF00FF;\n x = ((x >> 8) & mask8) | ((x & mask8) << 8);\n return (x >> 16) | (x << 16);\n#endif\n}\n\nstatic inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap64(x);\n#else\n static const uint64_t mask8 = 0x00FF00FF00FF00FF;\n static const uint64_t mask16 = 0x0000FFFF0000FFFF;\n x = ((x >> 8) & mask8) | ((x & mask8) << 8);\n x = ((x >> 16) & mask16) | ((x & mask16) << 16);\n return (x >> 32) | (x << 32);\n#endif\n}\n\n" + + "// --------\n\n// Clang also defines \"__GNUC__\".\n\nstatic inline uint16_t //\nwuffs_base__u16__byte_swapped(uint16_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap16(x);\n#else\n return (x >> 8) | (x << 8);\n#endif\n}\n\nstatic inline uint32_t //\nwuffs_base__u32__byte_swapped(uint32_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap32(x);\n#else\n static const uint32_t mask8 = 0x00FF00FF;\n x = ((x >> 8) & mask8) | ((x & mask8) << 8);\n return (x >> 16) | (x << 16);\n#endif\n}\n\nstatic inline uint64_t //\nwuffs_base__u64__byte_swapped(uint64_t x) {\n#if defined(__GNUC__)\n return __builtin_bswap64(x);\n#else\n static const uint64_t mask8 = 0x00FF00FF00FF00FF;\n static const uint64_t mask16 = 0x0000FFFF0000FFFF;\n x = ((x >> 8) & mask8) | ((x & mask8) << 8);\n x = ((x >> 16) & mask16) | ((x & mask16) << 16);\n return (x >> 32) | (x << 32);\n#endif\n}\n\n" + "" + "// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\n#define WUFFS_BASE__SLICE(T) \\\n struct { \\\n T* ptr; \\\n size_t len; \\\n }\n\n// WUFFS_BASE__TABLE is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\n#define WUFFS_BASE__TABLE(T) \\\n struct { \\\n T* ptr; \\\n size_t width; \\\n size_t height; \\\n size_t stride; \\\n }\n\ntypedef WUFFS_BASE__SLICE(uint8_t) wuffs_base__slice_u8;\ntypedef WUFFS_BASE__SLICE(uint16_t) wuffs_base__slice_u16;\ntypedef WUFFS_BASE__SLICE(uint32_t) wuffs_base__slice_u32;\ntypedef WUFFS_BASE__SLICE(uint64_t) wuffs_base__slice_u64;\n\ntypedef WUFFS_BASE__TABLE(uint8_t) wuffs_base__table_u8;\ntypedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;\ntypedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;\ntypedef WUFFS_BASE__TAB" + "LE(uint64_t) wuffs_base__table_u64;\n\n" + "" + "// ---------------- Ranges and Rects\n\n// Ranges are either inclusive (\"range_ii\") or exclusive (\"range_ie\") on the\n// high end. Both the \"ii\" and \"ie\" flavors are useful in practice.\n//\n// The \"ei\" and \"ee\" flavors also exist in theory, but aren't widely used. In\n// Wuffs, the low end is always inclusive.\n//\n// The \"ii\" (closed interval) flavor is useful when refining e.g. \"the set of\n// all uint32_t values\" to a contiguous subset: \"uint32_t values in the closed\n// interval [M, N]\", for uint32_t values M and N. An unrefined type (in other\n// words, the set of all uint32_t values) is not representable in the \"ie\"\n// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.\n//\n// On the other hand, the \"ie\" (half-open interval) flavor is recommended by\n// Dijkstra's \"Why numbering should start at zero\" at\n// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further\n// discussion of motivating rationale is at\n// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-close" + "d-inclusive\n//\n// For example, with \"ie\", the number of elements in \"uint32_t values in the\n// half-open interval [M, N)\" is equal to max(0, N-M). Furthermore, that number\n// of elements (in one dimension, a length, in two dimensions, a width or\n// height) is itself representable as a uint32_t without overflow, again for\n// uint32_t values M and N. In the contrasting \"ii\" flavor, the length of the\n// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a\n// uint32_t. In Wuffs, because of this potential overflow, the \"ie\" flavor has\n// length / width / height methods, but the \"ii\" flavor does not.\n//\n// It is valid for min > max (for range_ii) or for min >= max (for range_ie),\n// in which case the range is empty. There are multiple representations of an\n// empty range.\n\ntypedef struct wuffs_base__range_ii_u32__struct {\n uint32_t min_incl;\n uint32_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ii_u32__struct s);\n inline bool contains(uint" + - "32_t x);\n inline wuffs_base__range_ii_u32__struct intersect(\n wuffs_base__range_ii_u32__struct s);\n inline wuffs_base__range_ii_u32__struct unite(\n wuffs_base__range_ii_u32__struct s);\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u32;\n\nstatic inline bool wuffs_base__range_ii_u32__is_empty(\n wuffs_base__range_ii_u32* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool wuffs_base__range_ii_u32__equals(\n wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(&s));\n}\n\nstatic inline bool wuffs_base__range_ii_u32__contains(\n wuffs_base__range_ii_u32* r,\n uint32_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersect(\n wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuf" + - "fs_base__u32__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite(\n wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool wuffs_base__range_ii_u32::is_empty() {\n return wuffs_base__range_ii_u32__is_empty(this);\n}\n\ninline bool wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__equals(this, s);\n}\n\ninline bool wuffs_base__range_ii_u32::contains(uint32_t x) {\n return wuffs_base__range_ii_u32__contains(this, x);\n}\n\ninline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::intersect(\n wuffs_base__range" + - "_ii_u32 s) {\n return wuffs_base__range_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::unite(\n wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + + "32_t x);\n inline wuffs_base__range_ii_u32__struct intersect(\n wuffs_base__range_ii_u32__struct s);\n inline wuffs_base__range_ii_u32__struct unite(\n wuffs_base__range_ii_u32__struct s);\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u32;\n\nstatic inline bool //\nwuffs_base__range_ii_u32__is_empty(wuffs_base__range_ii_u32* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__equals(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline //\n wuffs_base__range_ii_u32\n wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r,\n wuffs_base__r" + + "ange_ii_u32 s) {\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline //\n wuffs_base__range_ii_u32\n wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u32__max(r->max_incl, s.max_incl);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u32::is_empty() {\n return wuffs_base__range_ii_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u32::contains(uint32_t x) {\n return wuffs_base__range_ii_u" + + "32__contains(this, x);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u32 //\nwuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) {\n return wuffs_base__range_ii_u32__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// --------\n\ntypedef struct wuffs_base__range_ie_u32__struct {\n uint32_t min_incl;\n uint32_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ie_u32__struct s);\n inline bool contains(uint32_t x);\n inline wuffs_base__range_ie_u32__struct intersect(\n wuffs_base__range_ie_u32__struct s);\n inline wuffs_base__range_ie_u32__struct unite(\n wuffs_base__range_ie_u32__struct s);\n inline uint32_t length();\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u32;\n\nstatic inline bool wuffs_base__range_ie_u32__is_empty(\n wuffs_base__range_ie_u32* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool wuffs_base__range_ie_u32__equals(\n wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(&s));\n}\n\nstatic inline bool wuffs_base__range_ie_u32__contains(\n wuffs_base__range_ie_u32* r" + - ",\n uint32_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersect(\n wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite(\n wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline uint32_t wuffs_base__range_ie_u32__length(\n wuffs_base__range_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool wuffs_base_" + - "_range_ie_u32::is_empty() {\n return wuffs_base__range_ie_u32__is_empty(this);\n}\n\ninline bool wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__equals(this, s);\n}\n\ninline bool wuffs_base__range_ie_u32::contains(uint32_t x) {\n return wuffs_base__range_ie_u32__contains(this, x);\n}\n\ninline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::intersect(\n wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::unite(\n wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__unite(this, s);\n}\n\ninline uint32_t wuffs_base__range_ie_u32::length() {\n return wuffs_base__range_ie_u32__length(this);\n}\n\n#endif // __cplusplus\n\n" + + "// --------\n\ntypedef struct wuffs_base__range_ie_u32__struct {\n uint32_t min_incl;\n uint32_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ie_u32__struct s);\n inline bool contains(uint32_t x);\n inline wuffs_base__range_ie_u32__struct intersect(\n wuffs_base__range_ie_u32__struct s);\n inline wuffs_base__range_ie_u32__struct unite(\n wuffs_base__range_ie_u32__struct s);\n inline uint32_t length();\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u32;\n\nstatic inline bool //\nwuffs_base__range_ie_u32__is_empty(wuffs_base__range_ie_u32* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__equals(wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u32__contains(w" + + "uffs_base__range_ie_u32* r, uint32_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__intersect(wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32__unite(wuffs_base__range_ie_u32* r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u32 t;\n t.min_incl = wuffs_base__u32__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u32__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline uint32_t //\nwuffs_base__range_ie_u32__length(wuffs_base__range_ie_u32* r) {\n return wuffs_base__u32__sa" + + "t_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ie_u32::is_empty() {\n return wuffs_base__range_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__range_ie_u32::contains(uint32_t x) {\n return wuffs_base__range_ie_u32__contains(this, x);\n}\n\ninline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u32 //\nwuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) {\n return wuffs_base__range_ie_u32__unite(this, s);\n}\n\ninline uint32_t //\nwuffs_base__range_ie_u32::length() {\n return wuffs_base__range_ie_u32__length(this);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// --------\n\ntypedef struct wuffs_base__range_ii_u64__struct {\n uint64_t min_incl;\n uint64_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ii_u64__struct s);\n inline bool contains(uint64_t x);\n inline wuffs_base__range_ii_u64__struct intersect(\n wuffs_base__range_ii_u64__struct s);\n inline wuffs_base__range_ii_u64__struct unite(\n wuffs_base__range_ii_u64__struct s);\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u64;\n\nstatic inline bool wuffs_base__range_ii_u64__is_empty(\n wuffs_base__range_ii_u64* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool wuffs_base__range_ii_u64__equals(\n wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u64__is_empty(r) &&\n wuffs_base__range_ii_u64__is_empty(&s));\n}\n\nstatic inline bool wuffs_base__range_ii_u64__contains(\n wuffs_base__range_ii_u64* r,\n uint64_t x) {\n return " + - "(r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersect(\n wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite(\n wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n if (wuffs_base__range_ii_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u64__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__max(r->max_incl, s.max_incl);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool wuffs_base__range_ii_u64::is_empty() {\n return wuffs_base__range_ii_u64__is_empty(this);\n}\n\ninline bool wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_" + - "ii_u64__equals(this, s);\n}\n\ninline bool wuffs_base__range_ii_u64::contains(uint64_t x) {\n return wuffs_base__range_ii_u64__contains(this, x);\n}\n\ninline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::intersect(\n wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::unite(\n wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + + "// --------\n\ntypedef struct wuffs_base__range_ii_u64__struct {\n uint64_t min_incl;\n uint64_t max_incl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ii_u64__struct s);\n inline bool contains(uint64_t x);\n inline wuffs_base__range_ii_u64__struct intersect(\n wuffs_base__range_ii_u64__struct s);\n inline wuffs_base__range_ii_u64__struct unite(\n wuffs_base__range_ii_u64__struct s);\n#endif // __cplusplus\n\n} wuffs_base__range_ii_u64;\n\nstatic inline bool //\nwuffs_base__range_ii_u64__is_empty(wuffs_base__range_ii_u64* r) {\n return r->min_incl > r->max_incl;\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__equals(wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u64__is_empty(r) &&\n wuffs_base__range_ii_u64__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ii_u64__contains(wuffs_base__range_ii_u64* r, u" + + "int64_t x) {\n return (r->min_incl <= x) && (x <= r->max_incl);\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64__intersect(wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl);\n return t;\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64__unite(wuffs_base__range_ii_u64* r,\n wuffs_base__range_ii_u64 s) {\n if (wuffs_base__range_ii_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u64__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ii_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_incl = wuffs_base__u64__max(r->max_incl, s.max_incl);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ii_u64::is_empty() {\n return wuffs_base__range_ii_u64__is_empty(this);\n}\n\ninline bool //\nwu" + + "ffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__equals(this, s);\n}\n\ninline bool //\nwuffs_base__range_ii_u64::contains(uint64_t x) {\n return wuffs_base__range_ii_u64__contains(this, x);\n}\n\ninline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64::intersect(wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ii_u64 //\nwuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) {\n return wuffs_base__range_ii_u64__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + "" + - "// --------\n\ntypedef struct wuffs_base__range_ie_u64__struct {\n uint64_t min_incl;\n uint64_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ie_u64__struct s);\n inline bool contains(uint64_t x);\n inline wuffs_base__range_ie_u64__struct intersect(\n wuffs_base__range_ie_u64__struct s);\n inline wuffs_base__range_ie_u64__struct unite(\n wuffs_base__range_ie_u64__struct s);\n inline uint64_t length();\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u64;\n\nstatic inline bool wuffs_base__range_ie_u64__is_empty(\n wuffs_base__range_ie_u64* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool wuffs_base__range_ie_u64__equals(\n wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u64__is_empty(r) &&\n wuffs_base__range_ie_u64__is_empty(&s));\n}\n\nstatic inline bool wuffs_base__range_ie_u64__contains(\n wuffs_base__range_ie_u64* r" + - ",\n uint64_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersect(\n wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite(\n wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n if (wuffs_base__range_ie_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u64__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline uint64_t wuffs_base__range_ie_u64__length(\n wuffs_base__range_ie_u64* r) {\n return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool wuffs_base_" + - "_range_ie_u64::is_empty() {\n return wuffs_base__range_ie_u64__is_empty(this);\n}\n\ninline bool wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__equals(this, s);\n}\n\ninline bool wuffs_base__range_ie_u64::contains(uint64_t x) {\n return wuffs_base__range_ie_u64__contains(this, x);\n}\n\ninline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::intersect(\n wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::unite(\n wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__unite(this, s);\n}\n\ninline uint64_t wuffs_base__range_ie_u64::length() {\n return wuffs_base__range_ie_u64__length(this);\n}\n\n#endif // __cplusplus\n\n" + + "// --------\n\ntypedef struct wuffs_base__range_ie_u64__struct {\n uint64_t min_incl;\n uint64_t max_excl;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__range_ie_u64__struct s);\n inline bool contains(uint64_t x);\n inline wuffs_base__range_ie_u64__struct intersect(\n wuffs_base__range_ie_u64__struct s);\n inline wuffs_base__range_ie_u64__struct unite(\n wuffs_base__range_ie_u64__struct s);\n inline uint64_t length();\n#endif // __cplusplus\n\n} wuffs_base__range_ie_u64;\n\nstatic inline bool //\nwuffs_base__range_ie_u64__is_empty(wuffs_base__range_ie_u64* r) {\n return r->min_incl >= r->max_excl;\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__equals(wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u64__is_empty(r) &&\n wuffs_base__range_ie_u64__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__range_ie_u64__contains(w" + + "uffs_base__range_ie_u64* r, uint64_t x) {\n return (r->min_incl <= x) && (x < r->max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64__intersect(wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64__unite(wuffs_base__range_ie_u64* r,\n wuffs_base__range_ie_u64 s) {\n if (wuffs_base__range_ie_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u64__is_empty(&s)) {\n return *r;\n }\n wuffs_base__range_ie_u64 t;\n t.min_incl = wuffs_base__u64__min(r->min_incl, s.min_incl);\n t.max_excl = wuffs_base__u64__max(r->max_excl, s.max_excl);\n return t;\n}\n\nstatic inline uint64_t //\nwuffs_base__range_ie_u64__length(wuffs_base__range_ie_u64* r) {\n return wuffs_base__u64__sa" + + "t_sub(r->max_excl, r->min_incl);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__range_ie_u64::is_empty() {\n return wuffs_base__range_ie_u64__is_empty(this);\n}\n\ninline bool //\nwuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__equals(this, s);\n}\n\ninline bool //\nwuffs_base__range_ie_u64::contains(uint64_t x) {\n return wuffs_base__range_ie_u64__contains(this, x);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__intersect(this, s);\n}\n\ninline wuffs_base__range_ie_u64 //\nwuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) {\n return wuffs_base__range_ie_u64__unite(this, s);\n}\n\ninline uint64_t //\nwuffs_base__range_ie_u64::length() {\n return wuffs_base__range_ie_u64__length(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\n// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the\n// integer grid. The \"ii\" means that the bounds are inclusive on the low end\n// and inclusive on the high end. It contains all points (x, y) such that\n// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.\n//\n// It is valid for min > max, in which case the rectangle is empty. There are\n// multiple representations of an empty rectangle.\n//\n// The X and Y axes increase right and down.\ntypedef struct wuffs_base__rect_ii_u32__struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_incl_x;\n uint32_t max_incl_y;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__rect_ii_u32__struct s);\n inline bool contains(uint32_t x, uint32_t y);\n inline wuffs_base__rect_ii_u32__struct intersect(\n wuffs_base__rect_ii_u32__struct s);\n inline wuffs_base__rect_ii_u32__struct unite(\n wuffs_base__rect_ii_u32__struct s);\n#endif // __cplusplus\n\n} wuffs_base__rect_ii_u32;\n\nstatic inline b" + - "ool wuffs_base__rect_ii_u32__is_empty(\n wuffs_base__rect_ii_u32* r) {\n return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y);\n}\n\nstatic inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) ||\n (wuffs_base__rect_ii_u32__is_empty(r) &&\n wuffs_base__rect_ii_u32__is_empty(&s));\n}\n\nstatic inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) &&\n (y <= r->max_incl_y);\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect(\n wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_i" + - "i_u32 s) {\n wuffs_base__rect_ii_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__min(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__min(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite(\n wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n if (wuffs_base__rect_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ii_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__max(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__max(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool wuffs_base__rect_ii_u32::is_empty() {\n return wuffs_base__rect_ii_u32__is_empty(thi" + - "s);\n}\n\ninline bool wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__equals(this, s);\n}\n\ninline bool wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) {\n return wuffs_base__rect_ii_u32__contains(this, x, y);\n}\n\ninline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::intersect(\n wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::unite(\n wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + + "ool //\nwuffs_base__rect_ii_u32__is_empty(wuffs_base__rect_ii_u32* r) {\n return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) ||\n (wuffs_base__rect_ii_u32__is_empty(r) &&\n wuffs_base__rect_ii_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) &&\n (y <= r->max_incl_y);\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32__intersect(wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n wuffs_b" + + "ase__rect_ii_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__min(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__min(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32__unite(wuffs_base__rect_ii_u32* r,\n wuffs_base__rect_ii_u32 s) {\n if (wuffs_base__rect_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ii_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ii_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_incl_x = wuffs_base__u32__max(r->max_incl_x, s.max_incl_x);\n t.max_incl_y = wuffs_base__u32__max(r->max_incl_y, s.max_incl_y);\n return t;\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ii_u32::is_empty() {\n return wuffs_base__rect_ii_u32__is" + + "_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) {\n return wuffs_base__rect_ii_u32__contains(this, x, y);\n}\n\ninline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ii_u32 //\nwuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) {\n return wuffs_base__rect_ii_u32__unite(this, s);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\n// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the\n// integer grid. The \"ie\" means that the bounds are inclusive on the low end\n// and exclusive on the high end. It contains all points (x, y) such that\n// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.\n//\n// It is valid for min >= max, in which case the rectangle is empty. There are\n// multiple representations of an empty rectangle, including a value with all\n// fields zero.\n//\n// The X and Y axes increase right and down.\ntypedef struct wuffs_base__rect_ie_u32__struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_excl_x;\n uint32_t max_excl_y;\n\n#ifdef __cplusplus\n inline bool is_empty();\n inline bool equals(wuffs_base__rect_ie_u32__struct s);\n inline bool contains(uint32_t x, uint32_t y);\n inline wuffs_base__rect_ie_u32__struct intersect(\n wuffs_base__rect_ie_u32__struct s);\n inline wuffs_base__rect_ie_u32__struct unite(\n wuffs_base__rect_ie_u32__struct s);\n inline uint32_t width(" + - ");\n inline uint32_t height();\n#endif // __cplusplus\n\n} wuffs_base__rect_ie_u32;\n\nstatic inline bool wuffs_base__rect_ie_u32__is_empty(\n wuffs_base__rect_ie_u32* r) {\n return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y);\n}\n\nstatic inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(&s));\n}\n\nstatic inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) &&\n (y < r->max_excl_y);\n}\n\nstatic inline wuffs_base__rect" + - "_ie_u32 wuffs_base__rect_ie_u32__intersect(\n wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__min(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__min(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite(\n wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__max(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__max(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline uint" + - "32_t wuffs_base__rect_ie_u32__width(\n wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__height(\n wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);\n}\n\n#ifdef __cplusplus\n\ninline bool wuffs_base__rect_ie_u32::is_empty() {\n return wuffs_base__rect_ie_u32__is_empty(this);\n}\n\ninline bool wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__equals(this, s);\n}\n\ninline bool wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) {\n return wuffs_base__rect_ie_u32__contains(this, x, y);\n}\n\ninline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::intersect(\n wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::unite(\n wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__unite(this, s);\n}\n\ninline uint32_t wuffs_base__rect_ie_u32:" + - ":width() {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t wuffs_base__rect_ie_u32::height() {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n\n" + + ");\n inline uint32_t height();\n#endif // __cplusplus\n\n} wuffs_base__rect_ie_u32;\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__is_empty(wuffs_base__rect_ie_u32* r) {\n return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y);\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&\n r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(&s));\n}\n\nstatic inline bool //\nwuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r,\n uint32_t x,\n uint32_t y) {\n return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) &&\n (y < r->max_excl_y);\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__intersect(wuf" + + "fs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__min(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__min(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32__unite(wuffs_base__rect_ie_u32* r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(&s)) {\n return *r;\n }\n wuffs_base__rect_ie_u32 t;\n t.min_incl_x = wuffs_base__u32__min(r->min_incl_x, s.min_incl_x);\n t.min_incl_y = wuffs_base__u32__min(r->min_incl_y, s.min_incl_y);\n t.max_excl_x = wuffs_base__u32__max(r->max_excl_x, s.max_excl_x);\n t.max_excl_y = wuffs_base__u32__max(r->max_excl_y, s.max_excl_y);\n return t;\n}\n\nstatic inlin" + + "e uint32_t //\nwuffs_base__rect_ie_u32__width(wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);\n}\n\nstatic inline uint32_t //\nwuffs_base__rect_ie_u32__height(wuffs_base__rect_ie_u32* r) {\n return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);\n}\n\n#ifdef __cplusplus\n\ninline bool //\nwuffs_base__rect_ie_u32::is_empty() {\n return wuffs_base__rect_ie_u32__is_empty(this);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__equals(this, s);\n}\n\ninline bool //\nwuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) {\n return wuffs_base__rect_ie_u32__contains(this, x, y);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__intersect(this, s);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) {\n return wuffs_base__rect_ie_u32__unite(this, s);\n}\n\ninline uint32_t //\nwuffs_" + + "base__rect_ie_u32::width() {\n return wuffs_base__rect_ie_u32__width(this);\n}\n\ninline uint32_t //\nwuffs_base__rect_ie_u32::height() {\n return wuffs_base__rect_ie_u32__height(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// ---------------- I/O\n\nstruct wuffs_base__io_buffer__struct;\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 struct wuffs_base__io_buffer__struct* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* bounds[2];\n } private_impl;\n} wuffs_base__io_reader;\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 struct wuffs_base__io_buffer__struct* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* bounds[2];\n } private_impl;\n} wuffs_base__io_writer;\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and leng" + - "th), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n\n#ifdef __cplusplus\n inline void compact();\n inline wuffs_base__io_reader reader();\n inline wuffs_base__io_writer writer();\n#endif // __cplusplus\n\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {\n if (!buf || (buf->ri == 0)) {\n return;\n }\n size_t n = buf->wi - buf->ri;\n if (n != 0) {\n memmove(buf->ptr, buf->ptr + buf->ri, n);\n }\n buf->wi = n;\n buf->ri = 0;\n}\n\nstatic inline wuffs_base__io_reader wuffs_base__io_buffer__reader(\n wuf" + - "fs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\nstatic inline wuffs_base__io_writer wuffs_base__io_buffer__writer(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline void wuffs_base__io_buffer__struct::compact() {\n wuffs_base__io_buffer__compact(this);\n}\n\ninline wuffs_base__io_reader wuffs_base__io_buffer__struct::reader() {\n return wuffs_base__io_buffer__reader(this);\n}\n\ninline wuffs_base__io_writer wuffs_base__io_buffer__struct::writer() {\n return wuffs_base__io_buffer__writer(this);\n}\n\n#endif // __cplusplus\n\n" + + "th), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct wuffs_base__io_buffer__struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n\n#ifdef __cplusplus\n inline void compact();\n inline wuffs_base__io_reader reader();\n inline wuffs_base__io_writer writer();\n#endif // __cplusplus\n\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_buffer__compact moves any written but unread bytes to the\n// start of the buffer.\nstatic inline void //\nwuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {\n if (!buf || (buf->ri == 0)) {\n return;\n }\n size_t n = buf->wi - buf->ri;\n if (n != 0) {\n memmove(buf->ptr, buf->ptr + buf->ri, n);\n }\n buf->wi = n;\n buf->ri = 0;\n}\n\nstatic inline wuffs_base__io_reader //\nwuffs_base__io_buffer__reader(" + + "wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\nstatic inline wuffs_base__io_writer //\nwuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__io_buffer__struct::compact() {\n wuffs_base__io_buffer__compact(this);\n}\n\ninline wuffs_base__io_reader //\nwuffs_base__io_buffer__struct::reader() {\n return wuffs_base__io_buffer__reader(this);\n}\n\ninline wuffs_base__io_writer //\nwuffs_base__io_buffer__struct::writer() {\n return wuffs_base__io_buffer__writer(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// ---------------- Images\n\n// wuffs_base__color_u32argb is an 8 bit per channel Alpha, Red, Green, Blue\n// color, as a uint32_t value. It is in word order, not byte order: its value\n// is always 0xAARRGGBB, regardless of endianness. It uses premultiplied alpha.\ntypedef uint32_t wuffs_base__color_u32argb;\n\n" + "" + @@ -78,71 +78,74 @@ const basePublicH = "" + "ecolor\n// with alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel format value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and the Wayland-" + "DRM library's WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these 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)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PIXEL_FORMAT_" + - "_RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_base__pixel" + - "_format f) {\n return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n" + + "_RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool //\nwuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool //\nwuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t //\nwuffs_base__pixel_format__num_planes(wuffs_base__pixel_fo" + + "rmat f) {\n return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n" + "" + "// --------\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >> shift_y.\n// where biases and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-im" + "age may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these 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)0x202000)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100)\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n 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 wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_y(\n 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 wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\n" + + "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)0x202000)\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100)\n\nstatic 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__shift_x(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t //\nwuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s,\n ui" + + "nt32_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__shift_y(wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\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 uint32_t num_loops;\n bool first_frame_is_opaque;\n } private_impl;\n\n#ifdef __cplusplus\n inline void initialize(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops,\n bool first_frame_is_opaque);\n inline void invalidate();\n inline bool is_valid();\n inline wuffs_base__pixel_format pixel_format();\n inline wuffs_base__pixel_subsampling pixel_subsampling();\n inline wuffs_base__rect_ie_u32 bounds();\n inline uint32_t width();\n inline uint32_t height();\n inline uint32_t num_loops();\n inline uint32_t first_frame_is_opaque();\n " + - "inline size_t pixbuf_size();\n#endif // __cplusplus\n\n} wuffs_base__image_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void wuffs_base__image_config__initialize(\n 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 uint32_t num_loops,\n bool first_frame_is_opaque) {\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 c->private_impl.num_loops = num_loops;\n c->private_impl.first_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n }\n *c = ((wuffs_base__image_config){});\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config*" + - " c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling\nwuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds(\n wuffs_base__image_config* c) {\n return c ? ((wuffs_base__rect_ie_u32){\n .min_incl_x = 0,\n .min_incl_y = 0,\n .max_excl_x = c->private_impl.width,\n .max_excl_y = c->private_impl.height,\n })\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return c ? c->private_impl" + - ".width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.num_loops : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__first_frame_is_opaque(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaque : false;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (c) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\n#ifdef __cplusplus\n\ninline vo" + - "id wuffs_base__image_config::initialize(\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height,\n num_loops, first_frame_is_opaque);\n}\n\ninline void wuffs_base__image_config::invalidate() {\n wuffs_base__image_config__invalidate(this);\n}\n\ninline bool wuffs_base__image_config::is_valid() {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format wuffs_base__image_config::pixel_format() {\n return wuffs_base__image_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling\nwuffs_base__image_config::pixel_subsampling() {\n return wuffs_base__image_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 wuffs_base__image_config::bounds() {\n return wuffs_base__image_config__bounds(this);\n}\n\ninline uint32_t wuffs_base__image_config::wi" + - "dth() {\n return wuffs_base__image_config__width(this);\n}\n\ninline uint32_t wuffs_base__image_config::height() {\n return wuffs_base__image_config__height(this);\n}\n\ninline uint32_t wuffs_base__image_config::num_loops() {\n return wuffs_base__image_config__num_loops(this);\n}\n\ninline uint32_t wuffs_base__image_config::first_frame_is_opaque() {\n return wuffs_base__image_config__first_frame_is_opaque(this);\n}\n\ninline size_t wuffs_base__image_config::pixbuf_size() {\n return wuffs_base__image_config__pixbuf_size(this);\n}\n\n#endif // __cplusplus\n\n" + + "inline size_t pixbuf_size();\n#endif // __cplusplus\n\n} wuffs_base__image_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void //\nwuffs_base__image_config__initialize(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 uint32_t num_loops,\n bool first_frame_is_opaque) {\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 c->private_impl.num_loops = num_loops;\n c->private_impl.fi" + + "rst_frame_is_opaque = first_frame_is_opaque;\n return;\n }\n }\n *c = ((wuffs_base__image_config){});\n}\n\nstatic inline void //\nwuffs_base__image_config__invalidate(wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool //\nwuffs_base__image_config__is_valid(wuffs_base__image_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format //\nwuffs_base__image_config__pixel_format(wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling //\nwuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__image_config__bounds(wuffs_base__image_config* c) {\n return c ? ((wuffs_base__rect_ie_u32){\n .min_incl_x = 0,\n .min_incl_y = 0,\n .max_excl_x = c->private_impl.width,\n .max_excl_y = c->privat" + + "e_impl.height,\n })\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t //\nwuffs_base__image_config__width(wuffs_base__image_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__image_config__height(wuffs_base__image_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__image_config__num_loops(wuffs_base__image_config* c) {\n return c ? c->private_impl.num_loops : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {\n return c ? c->private_impl.first_frame_is_opaque : false;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t //\nwuffs_base__image_config__pixbuf_size(wuffs_base__image_config* c) {\n if (c) {\n uint64_t wh =\n ((uint6" + + "4_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\n#ifdef __cplusplus\n\ninline void //\nwuffs_base__image_config::initialize(wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops,\n bool first_frame_is_opaque) {\n wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height,\n num_loops, 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() {\n return wuffs_base__image_config__is_valid(this);\n}\n\ninline wuffs_base__pixel_format //\nwuffs_base__image_config::pixel_format() {\n " + + "return wuffs_base__image_config__pixel_format(this);\n}\n\ninline wuffs_base__pixel_subsampling //\nwuffs_base__image_config::pixel_subsampling() {\n return wuffs_base__image_config__pixel_subsampling(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__image_config::bounds() {\n return wuffs_base__image_config__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__image_config::width() {\n return wuffs_base__image_config__width(this);\n}\n\ninline uint32_t //\nwuffs_base__image_config::height() {\n return wuffs_base__image_config__height(this);\n}\n\ninline uint32_t //\nwuffs_base__image_config::num_loops() {\n return wuffs_base__image_config__num_loops(this);\n}\n\ninline uint32_t //\nwuffs_base__image_config::first_frame_is_opaque() {\n return wuffs_base__image_config__first_frame_is_opaque(this);\n}\n\ninline size_t //\nwuffs_base__image_config::pixbuf_size() {\n return wuffs_base__image_config__pixbuf_size(this);\n}\n\n#endif // __cplusplus\n\n" + "" + "// --------\n\n// wuffs_base__animation_disposal encodes, for an animated image, how to\n// dispose of a frame after displaying it:\n// - None means to draw the next frame on top of this one.\n// - Restore Background means to clear the frame's dirty rectangle to \"the\n// background color\" (in practice, this means transparent black) before\n// drawing the next frame.\n// - Restore Previous means to undo the current frame, so that the next frame\n// is drawn on top of the previous one.\ntypedef uint8_t wuffs_base__animation_disposal;\n\n#define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \\\n ((wuffs_base__animation_disposal)1)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \\\n ((wuffs_base__animation_disposal)2)\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__image_config config;\n wuffs_base__pixel_buffer pixbuf;\n // TODO: color spaces.\n wuffs_base__rect_ie_u32 dirty_rect;\n wuffs_base__flicks duration;\n bool blend;\n wuffs_base__animation_disposal disposal;\n bool palette_changed;\n uint8_t palette[1024];\n } private_impl;\n\n#ifdef __cplusplus\n inline wuffs_base__status set_from_pixbuf(wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf);\n inline wuffs_base__status set_from_slice(wuffs_base__image_config config,\n wuffs_base__slice_u8 pixbuf_memory);\n inline void update(wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n bool blend,\n wuffs_base__animation_disposal disposal,\n " + - " wuffs_base__slice_u8 palette);\n inline wuffs_base__image_config* image_config();\n inline wuffs_base__rect_ie_u32 bounds();\n inline uint32_t width();\n inline uint32_t height();\n inline wuffs_base__rect_ie_u32 dirty_rect();\n inline wuffs_base__flicks duration();\n inline bool blend();\n inline wuffs_base__animation_disposal disposal();\n inline bool palette_changed();\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__image_buffer;\n\nstatic inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf(\n wuffs_base__image_buffer* b,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!b) {\n return WUFFS_BASE__ERROR_BAD_RECEIVER;\n }\n *b = ((wuffs_base__image_buffer){});\n b->private_impl.config = config;\n b->private_impl.pixbuf = pixbuf;\n return WUFFS_BASE__STATUS_OK;\n}\n\nstatic inline wuffs_base__status wuffs_base__image_buffer__set_from_slice(\n wuffs_base__image_buffer* b,\n w" + - "uffs_base__image_config config,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return WUFFS_BASE__ERROR_BAD_RECEIVER;\n }\n *b = ((wuffs_base__image_buffer){});\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)config.private_impl.width) *\n ((uint64_t)config.private_impl.height);\n if (wh > pixbuf_memory.len) {\n return WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT;\n }\n b->private_impl.config = config;\n wuffs_base__table_u8* tab = &b->private_impl.pixbuf.planes[0];\n tab->ptr = pixbuf_memory.ptr;\n tab->width = config.private_impl.width;\n tab->height = config.private_impl.height;\n tab->stride = config.private_impl.width;\n return WUFFS_BASE__STATUS_OK;\n}\n\n// The palette argument is ignored unless its length is exactly 1024.\nstatic inline void wuffs_base__image_buffer__update(\n wuffs_base__image_buffer* b,\n wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n bool blend,\n wuffs_base__animation_disposal dispo" + - "sal,\n wuffs_base__slice_u8 palette) {\n if (!b) {\n return;\n }\n\n // Clip the dirty_rect to the image bounds.\n dirty_rect.max_excl_x = wuffs_base__u32__min(\n dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);\n dirty_rect.max_excl_y = wuffs_base__u32__min(\n dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);\n b->private_impl.dirty_rect = dirty_rect;\n\n b->private_impl.duration = duration;\n b->private_impl.blend = blend;\n b->private_impl.disposal = disposal;\n b->private_impl.palette_changed = palette.ptr && (palette.len == 1024);\n if (b->private_impl.palette_changed) {\n memmove(b->private_impl.palette, palette.ptr, 1024);\n }\n}\n\n// wuffs_base__image_config returns the overall configuration for this frame.\nstatic inline wuffs_base__image_config* wuffs_base__image_buffer__image_config(\n wuffs_base__image_buffer* b) {\n return b ? &b->private_impl.config : NULL;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__bounds(\n wuffs_base__im" + - "age_buffer* b) {\n return b ? wuffs_base__image_config__bounds(&b->private_impl.config)\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t wuffs_base__image_buffer__width(\n wuffs_base__image_buffer* b) {\n return b ? wuffs_base__image_config__width(&b->private_impl.config) : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_buffer__height(\n wuffs_base__image_buffer* b) {\n return b ? wuffs_base__image_config__height(&b->private_impl.config) : 0;\n}\n\n// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n " + - "wuffs_base__image_buffer* b) {\n return b ? b->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__blend returns, for a transparent image, whether to\n// blend this frame with the existing canvas.\n//\n// In Porter-Duff compositing operator terminology, false means \"src\" and true\n// means \"src over dst\".\nstatic inline bool wuffs_base__image_buffer__blend(\n wuffs_base__image_buffer* b) {\n return b && b->private_impl.blend;\n}\n\n// wuffs_base__image_buffer__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal wuffs_base__image_buffer__disposal(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.disposal : 0;\n}\n\n// wuffs_base__image_buffer__palette_changed returns whether this frame's\n// palette differs from the previous frame. It is conservative and may return\n// false positives (but never false negatives).\nstatic inline bool wuffs_base__image_buffer__palette_changed(\n wuffs_base__image_buffer* b) {\n ret" + - "urn b && b->private_impl.palette_changed;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside b and has length 1024.\nstatic inline wuffs_base__slice_u8 wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* b) {\n return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,\n .len = 1024})\n : ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__table_u8 wuffs_base__image_buffer__plane(\n wuffs_base__image_buffer* b,\n uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.pixbuf.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#ifdef __cplusplus\n\ninline wuffs_base__status wuffs_base__image_buffer::set_from_pixbuf(\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n return wuffs_base__image_buffer__set_from_pixbuf(this, config, pixbuf);\n}\n\ninline wuffs_base__status wuffs_base__image_buffer" + - "::set_from_slice(\n wuffs_base__image_config config,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__image_buffer__set_from_slice(this, config, pixbuf_memory);\n}\n\ninline void wuffs_base__image_buffer::update(\n wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n bool blend,\n wuffs_base__animation_disposal disposal,\n wuffs_base__slice_u8 palette) {\n wuffs_base__image_buffer__update(this, dirty_rect, duration, blend, disposal,\n palette);\n}\n\ninline wuffs_base__image_config* wuffs_base__image_buffer::image_config() {\n return wuffs_base__image_buffer__image_config(this);\n}\n\ninline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::bounds() {\n return wuffs_base__image_buffer__bounds(this);\n}\n\ninline uint32_t wuffs_base__image_buffer::width() {\n return wuffs_base__image_buffer__width(this);\n}\n\ninline uint32_t wuffs_base__image_buffer::height() {\n return wuffs_base__image_buffer__height(this);\n}\n\ninline wuffs_base__rect_ie_u32 wuffs_b" + - "ase__image_buffer::dirty_rect() {\n return wuffs_base__image_buffer__dirty_rect(this);\n}\n\ninline wuffs_base__flicks wuffs_base__image_buffer::duration() {\n return wuffs_base__image_buffer__duration(this);\n}\n\ninline bool wuffs_base__image_buffer::blend() {\n return wuffs_base__image_buffer__blend(this);\n}\n\ninline wuffs_base__animation_disposal wuffs_base__image_buffer::disposal() {\n return wuffs_base__image_buffer__disposal(this);\n}\n\ninline bool wuffs_base__image_buffer::palette_changed() {\n return wuffs_base__image_buffer__palette_changed(this);\n}\n\ninline wuffs_base__slice_u8 wuffs_base__image_buffer::palette() {\n return wuffs_base__image_buffer__palette(this);\n}\n\ninline wuffs_base__table_u8 wuffs_base__image_buffer::plane(uint32_t p) {\n return wuffs_base__image_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_INCLUDE_GUARD__BASE_PUBLIC\n" + + " wuffs_base__slice_u8 palette);\n inline wuffs_base__image_config* image_config();\n inline wuffs_base__rect_ie_u32 bounds();\n inline uint32_t width();\n inline uint32_t height();\n inline wuffs_base__rect_ie_u32 dirty_rect();\n inline wuffs_base__flicks duration();\n inline bool blend();\n inline wuffs_base__animation_disposal disposal();\n inline bool palette_changed();\n inline wuffs_base__slice_u8 palette();\n inline wuffs_base__table_u8 plane(uint32_t p);\n#endif // __cplusplus\n\n} wuffs_base__image_buffer;\n\nstatic inline wuffs_base__status //\nwuffs_base__image_buffer__set_from_pixbuf(wuffs_base__image_buffer* b,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!b) {\n return WUFFS_BASE__ERROR_BAD_RECEIVER;\n }\n *b = ((wuffs_base__image_buffer){});\n b->private_impl.config = config;\n b->private_impl.pixbuf = pixbuf;\n return WUFFS_BASE__STATUS_OK;\n}\n\nstatic inline wuffs_base__status //\nw" + + "uffs_base__image_buffer__set_from_slice(wuffs_base__image_buffer* b,\n wuffs_base__image_config config,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return WUFFS_BASE__ERROR_BAD_RECEIVER;\n }\n *b = ((wuffs_base__image_buffer){});\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)config.private_impl.width) *\n ((uint64_t)config.private_impl.height);\n if (wh > pixbuf_memory.len) {\n return WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT;\n }\n b->private_impl.config = config;\n wuffs_base__table_u8* tab = &b->private_impl.pixbuf.planes[0];\n tab->ptr = pixbuf_memory.ptr;\n tab->width = config.private_impl.width;\n tab->height = config.private_impl.height;\n tab->stride = config.private_impl.width;\n return WUFFS_BASE__STATUS_OK;\n}\n\n// The palette argument is ignored unless its length is exactly 1024.\nstatic inline void //\nwuffs_base__image_buffer__update(wuffs_base_" + + "_image_buffer* b,\n wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n bool blend,\n wuffs_base__animation_disposal disposal,\n wuffs_base__slice_u8 palette) {\n if (!b) {\n return;\n }\n\n // Clip the dirty_rect to the image bounds.\n dirty_rect.max_excl_x = wuffs_base__u32__min(\n dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);\n dirty_rect.max_excl_y = wuffs_base__u32__min(\n dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);\n b->private_impl.dirty_rect = dirty_rect;\n\n b->private_impl.duration = duration;\n b->private_impl.blend = blend;\n b->private_impl.disposal = disposal;\n b->private_impl.palette_changed = palette.ptr && (palette.len == 1024);\n if (b->private_impl.palette_changed) {\n memmove(b->private_impl.palette, palette.ptr, 1024);\n }\n}\n\n// wuffs_base__image_config returns the" + + " overall configuration for this frame.\nstatic inline wuffs_base__image_config* //\nwuffs_base__image_buffer__image_config(wuffs_base__image_buffer* b) {\n return b ? &b->private_impl.config : NULL;\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__image_buffer__bounds(wuffs_base__image_buffer* b) {\n return b ? wuffs_base__image_config__bounds(&b->private_impl.config)\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t //\nwuffs_base__image_buffer__width(wuffs_base__image_buffer* b) {\n return b ? wuffs_base__image_config__width(&b->private_impl.config) : 0;\n}\n\nstatic inline uint32_t //\nwuffs_base__image_buffer__height(wuffs_base__image_buffer* b) {\n return b ? wuffs_base__image_config__height(&b->private_impl.config) : 0;\n}\n\n// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__image_buffer__dirty_rect(wuffs_base__image_buffer* b) {\n return b ? b-" + + ">private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks //\nwuffs_base__image_buffer__duration(wuffs_base__image_buffer* b) {\n return b ? b->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__blend returns, for a transparent image, whether to\n// blend this frame with the existing canvas.\n//\n// In Porter-Duff compositing operator terminology, false means \"src\" and true\n// means \"src over dst\".\nstatic inline bool //\nwuffs_base__image_buffer__blend(wuffs_base__image_buffer* b) {\n return b && b->private_impl.blend;\n}\n\n// wuffs_base__image_buffer__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal //\nwuffs_base__image_buffer__disposal(wuffs_base__image_buffer* b) {\n return b ? b->private_impl.disposal : 0;\n}\n\n// wuffs_base__ima" + + "ge_buffer__palette_changed returns whether this frame's\n// palette differs from the previous frame. It is conservative and may return\n// false positives (but never false negatives).\nstatic inline bool //\nwuffs_base__image_buffer__palette_changed(wuffs_base__image_buffer* b) {\n return b && b->private_impl.palette_changed;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside b and has length 1024.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__image_buffer__palette(wuffs_base__image_buffer* b) {\n return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,\n .len = 1024})\n : ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__table_u8 //\nwuffs_base__image_buffer__plane(wuffs_base__image_buffer* b, uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.pixbuf.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#ifdef __cplusp" + + "lus\n\ninline wuffs_base__status //\nwuffs_base__image_buffer::set_from_pixbuf(wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n return wuffs_base__image_buffer__set_from_pixbuf(this, config, pixbuf);\n}\n\ninline wuffs_base__status //\nwuffs_base__image_buffer::set_from_slice(wuffs_base__image_config config,\n wuffs_base__slice_u8 pixbuf_memory) {\n return wuffs_base__image_buffer__set_from_slice(this, config, pixbuf_memory);\n}\n\ninline void //\nwuffs_base__image_buffer::update(wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n bool blend,\n wuffs_base__animation_disposal disposal,\n wuffs_base__slice_u8 palette) {\n wuffs_base__image_buffer__update(this, dirty_rect, duration, blend, disposal,\n palette);\n}\n\ninline wuffs_base__image_config* /" + + "/\nwuffs_base__image_buffer::image_config() {\n return wuffs_base__image_buffer__image_config(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__image_buffer::bounds() {\n return wuffs_base__image_buffer__bounds(this);\n}\n\ninline uint32_t //\nwuffs_base__image_buffer::width() {\n return wuffs_base__image_buffer__width(this);\n}\n\ninline uint32_t //\nwuffs_base__image_buffer::height() {\n return wuffs_base__image_buffer__height(this);\n}\n\ninline wuffs_base__rect_ie_u32 //\nwuffs_base__image_buffer::dirty_rect() {\n return wuffs_base__image_buffer__dirty_rect(this);\n}\n\ninline wuffs_base__flicks //\nwuffs_base__image_buffer::duration() {\n return wuffs_base__image_buffer__duration(this);\n}\n\ninline bool //\nwuffs_base__image_buffer::blend() {\n return wuffs_base__image_buffer__blend(this);\n}\n\ninline wuffs_base__animation_disposal //\nwuffs_base__image_buffer::disposal() {\n return wuffs_base__image_buffer__disposal(this);\n}\n\ninline bool //\nwuffs_base__image_buffer::palette_changed() {\n return wuffs_base__image" + + "_buffer__palette_changed(this);\n}\n\ninline wuffs_base__slice_u8 //\nwuffs_base__image_buffer::palette() {\n return wuffs_base__image_buffer__palette(this);\n}\n\ninline wuffs_base__table_u8 //\nwuffs_base__image_buffer::plane(uint32_t p) {\n return wuffs_base__image_buffer__plane(this, p);\n}\n\n#endif // __cplusplus\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_INCLUDE_GUARD__BASE_PUBLIC\n" + "" const basePrivateH = "" + "#ifndef WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n#define WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n\n// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x)\n\n// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.\n// It's not foolproof, given C doesn't automatically zero memory before use,\n// but it should catch 99.99% of cases.\n//\n// Its (non-zero) value is arbitrary" + ", based on md5sum(\"wuffs\").\n#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71)\n\n// Denote intentional fallthroughs for -Wimplicit-fallthrough.\n//\n// The order matters here. Clang also defines \"__GNUC__\".\n#if defined(__clang__) && __cplusplus >= 201103L\n#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]\n#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)\n#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough))\n#else\n#define WUFFS_BASE__FALLTHROUGH\n#endif\n\n// Use switch cases for coroutine suspension points, similar to the technique\n// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html\n//\n// We use trivial macros instead of an explicit assignment and case statement\n// so that clang-format doesn't get confused by the unusual \"case\"s.\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:;\n#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \\\n coro_susp_point = n; \\\n WUFFS_BASE__FALLTHROUGH; \\\n case n:;\n\n#define WUFFS_BASE__CORO" + "UTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (status < 0) { \\\n goto exit; \\\n } else if (status == 0) { \\\n goto ok; \\\n } \\\n coro_susp_point = n; \\\n goto suspend; \\\n case n:;\n\n// Clang also defines \"__GNUC__\".\n#if defined(__GNUC__)\n#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are static, so that linking multiple wuffs .o files won't complain " + - "about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct wuffs_base__return_empty_struct() {\n return ((wuffs_base__empty_struct){});\n}\n\n" + + "about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to guide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__return_empty_struct() {\n return ((wuffs_base__empty_struct){});\n}\n\n" + "" + - "// ---------------- Numeric Types\n\nstatic inline uint8_t wuffs_base__load_u8be(uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t wuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t wuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t wuffs_base__load_u24be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u24le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t wuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint" + - "32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t wuffs_base__load_u40be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t wuffs_base__load_u40le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t wuffs_base__load_u48be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) |\n ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t wuffs_base__load_u48le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline uint64_t wuffs_base__load_u56be(uint8_t* p) {" + - "\n return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) |\n ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) |\n ((uint64_t)(p[6]) << 0);\n}\n\nstatic inline uint64_t wuffs_base__load_u56le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48);\n}\n\nstatic inline uint64_t wuffs_base__load_u64be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |\n ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |\n ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |\n ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);\n}\n\nstatic inline uint64_t wuffs_base__load_u64le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64" + - "_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);\n}\n\n" + + "// ---------------- Numeric Types\n\nstatic inline uint8_t //\nwuffs_base__load_u8be(uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uin" + + "t32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |\n ((uint64_t)(p[4]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u48be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) |\n ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |\n ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u48le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);\n}\n\nstatic inline u" + + "int64_t //\nwuffs_base__load_u56be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) |\n ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) |\n ((uint64_t)(p[6]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u56le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u64be(uint8_t* p) {\n return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |\n ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |\n ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |\n ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u64le(uint8_t* p) {\n return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |\n ((uint64_t)" + + "(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |\n ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |\n ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56);\n}\n\n" + "" + - "// --------\n\nstatic inline void wuffs_base__store_u8be(uint8_t* p, uint8_t x) {\n p[0] = x;\n}\n\nstatic inline void wuffs_base__store_u16be(uint8_t* p, uint16_t x) {\n p[0] = x >> 8;\n p[1] = x >> 0;\n}\n\nstatic inline void wuffs_base__store_u16le(uint8_t* p, uint16_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n}\n\nstatic inline void wuffs_base__store_u24be(uint8_t* p, uint32_t x) {\n p[0] = x >> 16;\n p[1] = x >> 8;\n p[2] = x >> 0;\n}\n\nstatic inline void wuffs_base__store_u24le(uint8_t* p, uint32_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n}\n\nstatic inline void wuffs_base__store_u32be(uint8_t* p, uint32_t x) {\n p[0] = x >> 24;\n p[1] = x >> 16;\n p[2] = x >> 8;\n p[3] = x >> 0;\n}\n\nstatic inline void wuffs_base__store_u32le(uint8_t* p, uint32_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n}\n\nstatic inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) {\n p[0] = x >> 32;\n p[1] = x >> 24;\n p[2] = x >> 16;\n p[3] = x >> 8;\n p[4] = x >> 0;\n}\n\nstatic inline void wuffs_" + - "base__store_u40le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n}\n\nstatic inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) {\n p[0] = x >> 40;\n p[1] = x >> 32;\n p[2] = x >> 24;\n p[3] = x >> 16;\n p[4] = x >> 8;\n p[5] = x >> 0;\n}\n\nstatic inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n p[5] = x >> 40;\n}\n\nstatic inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) {\n p[0] = x >> 48;\n p[1] = x >> 40;\n p[2] = x >> 32;\n p[3] = x >> 24;\n p[4] = x >> 16;\n p[5] = x >> 8;\n p[6] = x >> 0;\n}\n\nstatic inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n p[5] = x >> 40;\n p[6] = x >> 48;\n}\n\nstatic inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) {\n p[0] = x >> 56;\n p[1] = x >> 48;\n p[2] = x >> 40;\n p[3] = x >> 32;\n" + - " p[4] = x >> 24;\n p[5] = x >> 16;\n p[6] = x >> 8;\n p[7] = x >> 0;\n}\n\nstatic inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n p[5] = x >> 40;\n p[6] = x >> 48;\n p[7] = x >> 56;\n}\n\n" + + "// --------\n\nstatic inline void //\nwuffs_base__store_u8be(uint8_t* p, uint8_t x) {\n p[0] = x;\n}\n\nstatic inline void //\nwuffs_base__store_u16be(uint8_t* p, uint16_t x) {\n p[0] = x >> 8;\n p[1] = x >> 0;\n}\n\nstatic inline void //\nwuffs_base__store_u16le(uint8_t* p, uint16_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n}\n\nstatic inline void //\nwuffs_base__store_u24be(uint8_t* p, uint32_t x) {\n p[0] = x >> 16;\n p[1] = x >> 8;\n p[2] = x >> 0;\n}\n\nstatic inline void //\nwuffs_base__store_u24le(uint8_t* p, uint32_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n}\n\nstatic inline void //\nwuffs_base__store_u32be(uint8_t* p, uint32_t x) {\n p[0] = x >> 24;\n p[1] = x >> 16;\n p[2] = x >> 8;\n p[3] = x >> 0;\n}\n\nstatic inline void //\nwuffs_base__store_u32le(uint8_t* p, uint32_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n}\n\nstatic inline void //\nwuffs_base__store_u40be(uint8_t* p, uint64_t x) {\n p[0] = x >> 32;\n p[1] = x >> 24;\n p[2] = x >> 16;\n p[3] = x >> 8;\n p[4] = x >>" + + " 0;\n}\n\nstatic inline void //\nwuffs_base__store_u40le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n}\n\nstatic inline void //\nwuffs_base__store_u48be(uint8_t* p, uint64_t x) {\n p[0] = x >> 40;\n p[1] = x >> 32;\n p[2] = x >> 24;\n p[3] = x >> 16;\n p[4] = x >> 8;\n p[5] = x >> 0;\n}\n\nstatic inline void //\nwuffs_base__store_u48le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n p[5] = x >> 40;\n}\n\nstatic inline void //\nwuffs_base__store_u56be(uint8_t* p, uint64_t x) {\n p[0] = x >> 48;\n p[1] = x >> 40;\n p[2] = x >> 32;\n p[3] = x >> 24;\n p[4] = x >> 16;\n p[5] = x >> 8;\n p[6] = x >> 0;\n}\n\nstatic inline void //\nwuffs_base__store_u56le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n p[5] = x >> 40;\n p[6] = x >> 48;\n}\n\nstatic inline void //\nwuffs_base__store_u64be(uint8_t* p, uint64_t x) {\n p[0] = x >> 56" + + ";\n p[1] = x >> 48;\n p[2] = x >> 40;\n p[3] = x >> 32;\n p[4] = x >> 24;\n p[5] = x >> 16;\n p[6] = x >> 8;\n p[7] = x >> 0;\n}\n\nstatic inline void //\nwuffs_base__store_u64le(uint8_t* p, uint64_t x) {\n p[0] = x >> 0;\n p[1] = x >> 8;\n p[2] = x >> 16;\n p[3] = x >> 24;\n p[4] = x >> 32;\n p[5] = x >> 40;\n p[6] = x >> 48;\n p[7] = x >> 56;\n}\n\n" + "" + - "// --------\n\nstatic inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_sub(*x, y);\n}\n\nstatic inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_sub(*x, y);\n}\n\nstatic inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_sub(*x, y);\n}\n\nstatic inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_add(*x, y);\n}\n\nstatic inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_sub(*x, y);\n}\n\n" + + "// --------\n\nstatic inline void //\nwuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {\n *x = wuffs_base__u8__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {\n *x = wuffs_base__u16__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {\n *x = wuffs_base__u32__sat_sub(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_add(*x, y);\n}\n\nstatic inline void //\nwuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {\n *x = wuffs_base__u64__sat_sub(*x, y);\n}\n\n" + "" + - "// ---------------- Slices and Tables\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(\n wuffs_base__slice_u8 s,\n uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(\n wuffs_base__slice_u8 s,\n uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(\n wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u" + - "8 wuffs_base__slice_u8__prefix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\n" + + "// ---------------- Slices and Tables\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up" + + "_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t //\nwuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, leng" + + "th);\n }\n return length;\n}\n\n" + "" + - "// --------\n\nstatic inline wuffs_base__slice_u8 wuffs_base__table_u8__row(\n wuffs_base__table_u8 t,\n uint32_t y) {\n if (y < t.height) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr + (t.stride * y),\n .len = t.width,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" + + "// --------\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {\n if (y < t.height) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr + (t.stride * y),\n .len = t.width,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" + "" + - "// ---------------- Utility\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_incl) {\n return ((wuffs_base__range_ii_u32){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__utility__make_range_ie_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_excl) {\n return ((wuffs_base__range_ie_u32){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__utility__make_range_ii_u64(\n wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_incl) {\n return ((wuffs_base__range_ii_u64){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__utility__make_range_ie_u64(\n wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_excl) {\n return ((wuffs_base__range_ie_u64){\n " + - " .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_incl_x,\n uint32_t max_incl_y) {\n return ((wuffs_base__rect_ii_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_incl_x = max_incl_x,\n .max_incl_y = max_incl_y,\n });\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_excl_x = max_excl_x,\n .max_excl_y = max_excl_y,\n });\n}\n\n" + + "// ---------------- Utility\n\nstatic inline wuffs_base__range_ii_u32 //\nwuffs_base__utility__make_range_ii_u32(wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_incl) {\n return ((wuffs_base__range_ii_u32){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u32 //\nwuffs_base__utility__make_range_ie_u32(wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_excl) {\n return ((wuffs_base__range_ie_u32){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__range_ii_u64 //\nwuffs_base__utility__make_range_ii_u64(wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_incl) {\n return ((wuffs_base__range_ii_u64){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });" + + "\n}\n\nstatic inline wuffs_base__range_ie_u64 //\nwuffs_base__utility__make_range_ie_u64(wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_excl) {\n return ((wuffs_base__range_ie_u64){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__rect_ii_u32 //\nwuffs_base__utility__make_rect_ii_u32(wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_incl_x,\n uint32_t max_incl_y) {\n return ((wuffs_base__rect_ii_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_incl_x = max_incl_x,\n .max_incl_y = max_incl_y,\n });\n}\n\nstatic inline wuffs_base__rect_ie_u32 //\nwuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored,\n uint32_t min_incl" + + "_x,\n uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_excl_x = max_excl_x,\n .max_excl_y = max_excl_y,\n });\n}\n\n" + "" + - "// ---------------- I/O\n\nstatic inline bool wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {\n return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) &&\n (buf.wi >= buf.ri);\n}\n\nstatic inline bool wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.bounds[1]);\n}\n\nstatic inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) bounds.\n return buf ? ((buf->ptr <= o.private_impl.bounds[0]) &&\n (o.private_impl.bounds[0] <= o.private_impl.bounds[1]) &&\n (o.private_impl.bounds[1] <= buf->ptr + buf->len))\n : ((o.private_impl.bounds[0] == NULL) &&\n (o.private_impl.bounds[1] == NULL));\n}\n\nstatic inline bool wuf" + - "fs_base__io_writer__is_valid(wuffs_base__io_writer o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) bounds.\n return buf ? ((buf->ptr <= o.private_impl.bounds[0]) &&\n (o.private_impl.bounds[0] <= o.private_impl.bounds[1]) &&\n (o.private_impl.bounds[1] <= buf->ptr + buf->len))\n : ((o.private_impl.bounds[0] == NULL) &&\n (o.private_impl.bounds[1] == NULL));\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_n_from_history(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n if (!distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling" + - " by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_n_from_history Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__io_writer__copy_n_from_history_fast below.\n //\n // Alternatively, or additionally, have a sloppy_copy_n_from_history method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__io_writer__copy_n_from_history_fast is like the\n// wuffs_base__io_writer__copy_n_from_history function above, but has stronger\n// pre-conditions. The caller needs to prove that:\n// - distance > 0\n// - distance <= (*ptr_" + - "ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_n_from_reader(\n uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n uint8_t** ptr_ioptr_r,\n uint8_t* iobounds1_r) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = length;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n uint8_t* ioptr_r = *ptr_ioptr_r;\n if (n > ((size_t)(iobounds1_r - ioptr_r))) {\n n = iobounds1_r - ioptr_r;\n }\n if (n > 0) {\n memmove(ioptr_w, ioptr_r, n);\n *ptr_ioptr_w += n;\n *ptr_i" + - "optr_r += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__io_writer__copy_from_slice(\n uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_n_from_slice(\n uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_reader__set_limit(\n wuffs_base__io_reader* o,\n uint8_t* ioptr_r,\n uint64_t limit) {\n if (o && (((size_t)(o->p" + - "rivate_impl.bounds[1] - ioptr_r)) > limit)) {\n o->private_impl.bounds[1] = ioptr_r + limit;\n }\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_reader__set_mark(\n wuffs_base__io_reader* o,\n uint8_t* mark) {\n o->private_impl.bounds[0] = mark;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_writer__set(\n wuffs_base__io_writer* o,\n wuffs_base__io_buffer* b,\n uint8_t** ioptr1_ptr,\n uint8_t** ioptr2_ptr,\n wuffs_base__slice_u8 s) {\n b->ptr = s.ptr;\n b->len = s.len;\n b->wi = 0;\n b->ri = 0;\n b->closed = false;\n o->private_impl.buf = b;\n o->private_impl.bounds[0] = s.ptr;\n o->private_impl.bounds[1] = s.ptr + s.len;\n *ioptr1_ptr = s.ptr;\n *ioptr2_ptr = s.ptr + s.len;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_writer__set_mark(\n wuffs_base__io_writer* o,\n uint8_t* mark) {\n o->private_impl.bounds[0] = mark;\n return ((wuffs_bas" + - "e__empty_struct){});\n}\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n" + + "// ---------------- I/O\n\nstatic inline bool //\nwuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {\n return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) &&\n (buf.wi >= buf.ri);\n}\n\nstatic inline bool //\nwuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.bounds[1]);\n}\n\nstatic inline bool //\nwuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) bounds.\n return buf ? ((buf->ptr <= o.private_impl.bounds[0]) &&\n (o.private_impl.bounds[0] <= o.private_impl.bounds[1]) &&\n (o.private_impl.bounds[1] <= buf->ptr + buf->len))\n : ((o.private_impl.bounds[0] == NULL) &&\n (o.private_impl.bounds[1] == NULL));\n}\n\nstatic inl" + + "ine bool //\nwuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) bounds.\n return buf ? ((buf->ptr <= o.private_impl.bounds[0]) &&\n (o.private_impl.bounds[0] <= o.private_impl.bounds[1]) &&\n (o.private_impl.bounds[1] <= buf->ptr + buf->len))\n : ((o.private_impl.bounds[0] == NULL) &&\n (o.private_impl.bounds[1] == NULL));\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n if (!distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distanc" + + "e)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_n_from_history Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__io_writer__copy_n_from_history_fast below.\n //\n // Alternatively, or additionally, have a sloppy_copy_n_from_history method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__io_writer__copy_n_from_history_fast is like the\n// " + + "wuffs_base__io_writer__copy_n_from_history function above, but has stronger\n// pre-conditions. The caller needs to prove that:\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n " + + " uint32_t length,\n uint8_t** ptr_ioptr_r,\n uint8_t* iobounds1_r) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = length;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n uint8_t* ioptr_r = *ptr_ioptr_r;\n if (n > ((size_t)(iobounds1_r - ioptr_r))) {\n n = iobounds1_r - ioptr_r;\n }\n if (n > 0) {\n memmove(ioptr_w, ioptr_r, n);\n *ptr_ioptr_w += n;\n *ptr_ioptr_r += n;\n }\n return n;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer" + + "__copy_n_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* ioptr_r,\n uint64_t limit) {\n if (o && (((size_t)(o->private_impl.bounds[1] - ioptr_r)) > limit)) {\n o->private_impl.bounds[1] = ioptr_r + limit;\n }\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n o->private_impl.bounds[0] = " + + "mark;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n wuffs_base__io_buffer* b,\n uint8_t** ioptr1_ptr,\n uint8_t** ioptr2_ptr,\n wuffs_base__slice_u8 s) {\n b->ptr = s.ptr;\n b->len = s.len;\n b->wi = 0;\n b->ri = 0;\n b->closed = false;\n o->private_impl.buf = b;\n o->private_impl.bounds[0] = s.ptr;\n o->private_impl.bounds[1] = s.ptr + s.len;\n *ioptr1_ptr = s.ptr;\n *ioptr2_ptr = s.ptr + s.len;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {\n o->private_impl.bounds[0] = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // WUFFS_INCLUDE_GUARD__BASE_PRIVATE\n" + "" const baseImplC = "" + - "// Copyright 2018 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// !! INSERT base-public.h.\n\n#ifdef WUFFS_IMPLEMENTATION\n\n// !! INSERT base-private.h.\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE)\n\n// !! INSERT wuffs_base__status__string data.\n\nconst char* wuffs_base__status__string(wuffs_base__status s) {\n uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)];\n return o ? wuffs_base__status__string_data + o : \"unknown status\";\n}\n\n#endif // " + - "!defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE)\n\n#endif // WUFFS_IMPLEMENTATION\n" + + "// Copyright 2018 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n// !! INSERT base-public.h.\n\n#ifdef WUFFS_IMPLEMENTATION\n\n// !! INSERT base-private.h.\n\n#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BASE)\n\n// !! INSERT wuffs_base__status__string data.\n\nconst char* //\nwuffs_base__status__string(wuffs_base__status s) {\n uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)];\n return o ? wuffs_base__status__string_data + o : \"unknown status\";\n}\n\n#endif " + + " // !defined(WUFFS_CONFIG__MODULES) ||\n // defined(WUFFS_CONFIG__MODULE__BASE)\n\n#endif // WUFFS_IMPLEMENTATION\n" + "" type template_args_short_read struct { diff --git a/release/c/unsupported-snapshot.h b/release/c/unsupported-snapshot.h index 2ba50f47..49ba155f 100644 --- a/release/c/unsupported-snapshot.h +++ b/release/c/unsupported-snapshot.h @@ -145,19 +145,23 @@ typedef int32_t wuffs_base__status; #define WUFFS_BASE__SUSPENSION_SHORT_READ 33554432 // 0x02000000 #define WUFFS_BASE__SUSPENSION_SHORT_WRITE 50331648 // 0x03000000 -static inline bool wuffs_base__status__is_error(wuffs_base__status s) { +static inline bool // +wuffs_base__status__is_error(wuffs_base__status s) { return s < 0; } -static inline bool wuffs_base__status__is_ok(wuffs_base__status s) { +static inline bool // +wuffs_base__status__is_ok(wuffs_base__status s) { return s == 0; } -static inline bool wuffs_base__status__is_suspension(wuffs_base__status s) { +static inline bool // +wuffs_base__status__is_suspension(wuffs_base__status s) { return s > 0; } -const char* wuffs_base__status__string(wuffs_base__status s); +const char* // +wuffs_base__status__string(wuffs_base__status s); // -------- @@ -170,35 +174,43 @@ typedef int64_t wuffs_base__flicks; // ---------------- Numeric Types -static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__min(uint8_t x, uint8_t y) { return x < y ? x : y; } -static inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__max(uint8_t x, uint8_t y) { return x > y ? x : y; } -static inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__min(uint16_t x, uint16_t y) { return x < y ? x : y; } -static inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__max(uint16_t x, uint16_t y) { return x > y ? x : y; } -static inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__min(uint32_t x, uint32_t y) { return x < y ? x : y; } -static inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__max(uint32_t x, uint32_t y) { return x > y ? x : y; } -static inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__min(uint64_t x, uint64_t y) { return x < y ? x : y; } -static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__max(uint64_t x, uint64_t y) { return x > y ? x : y; } @@ -210,49 +222,57 @@ static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) { // It is important that the underlying types are unsigned integers, as signed // integer arithmetic overflow is undefined behavior in C. -static inline uint8_t wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { uint8_t res = x + y; res |= -(res < x); return res; } -static inline uint8_t wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { +static inline uint8_t // +wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { uint8_t res = x - y; res &= -(res <= x); return res; } -static inline uint16_t wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { uint16_t res = x + y; res |= -(res < x); return res; } -static inline uint16_t wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { +static inline uint16_t // +wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { uint16_t res = x - y; res &= -(res <= x); return res; } -static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { uint32_t res = x + y; res |= -(res < x); return res; } -static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) { +static inline uint32_t // +wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) { uint32_t res = x - y; res &= -(res <= x); return res; } -static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__sat_add(uint64_t x, uint64_t y) { uint64_t res = x + y; res |= -(res < x); return res; } -static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { +static inline uint64_t // +wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { uint64_t res = x - y; res &= -(res <= x); return res; @@ -262,7 +282,8 @@ static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { // Clang also defines "__GNUC__". -static inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) { +static inline uint16_t // +wuffs_base__u16__byte_swapped(uint16_t x) { #if defined(__GNUC__) return __builtin_bswap16(x); #else @@ -270,7 +291,8 @@ static inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) { #endif } -static inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) { +static inline uint32_t // +wuffs_base__u32__byte_swapped(uint32_t x) { #if defined(__GNUC__) return __builtin_bswap32(x); #else @@ -280,7 +302,8 @@ static inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) { #endif } -static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) { +static inline uint64_t // +wuffs_base__u64__byte_swapped(uint64_t x) { #if defined(__GNUC__) return __builtin_bswap64(x); #else @@ -373,37 +396,38 @@ typedef struct wuffs_base__range_ii_u32__struct { } wuffs_base__range_ii_u32; -static inline bool wuffs_base__range_ii_u32__is_empty( - wuffs_base__range_ii_u32* r) { +static inline bool // +wuffs_base__range_ii_u32__is_empty(wuffs_base__range_ii_u32* r) { return r->min_incl > r->max_incl; } -static inline bool wuffs_base__range_ii_u32__equals( - wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline bool // +wuffs_base__range_ii_u32__equals(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) || (wuffs_base__range_ii_u32__is_empty(r) && wuffs_base__range_ii_u32__is_empty(&s)); } -static inline bool wuffs_base__range_ii_u32__contains( - wuffs_base__range_ii_u32* r, - uint32_t x) { +static inline bool // +wuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) { return (r->min_incl <= x) && (x <= r->max_incl); } -static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersect( - wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline // + wuffs_base__range_ii_u32 + wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { wuffs_base__range_ii_u32 t; t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl); return t; } -static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite( - wuffs_base__range_ii_u32* r, - wuffs_base__range_ii_u32 s) { +static inline // + wuffs_base__range_ii_u32 + wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r, + wuffs_base__range_ii_u32 s) { if (wuffs_base__range_ii_u32__is_empty(r)) { return s; } @@ -418,25 +442,28 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite( #ifdef __cplusplus -inline bool wuffs_base__range_ii_u32::is_empty() { +inline bool // +wuffs_base__range_ii_u32::is_empty() { return wuffs_base__range_ii_u32__is_empty(this); } -inline bool wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) { +inline bool // +wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) { return wuffs_base__range_ii_u32__equals(this, s); } -inline bool wuffs_base__range_ii_u32::contains(uint32_t x) { +inline bool // +wuffs_base__range_ii_u32::contains(uint32_t x) { return wuffs_base__range_ii_u32__contains(this, x); } -inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::intersect( - wuffs_base__range_ii_u32 s) { +inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) { return wuffs_base__range_ii_u32__intersect(this, s); } -inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::unite( - wuffs_base__range_ii_u32 s) { +inline wuffs_base__range_ii_u32 // +wuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) { return wuffs_base__range_ii_u32__unite(this, s); } @@ -461,37 +488,36 @@ typedef struct wuffs_base__range_ie_u32__struct { } wuffs_base__range_ie_u32; -static inline bool wuffs_base__range_ie_u32__is_empty( - wuffs_base__range_ie_u32* r) { +static inline bool // +wuffs_base__range_ie_u32__is_empty(wuffs_base__range_ie_u32* r) { return r->min_incl >= r->max_excl; } -static inline bool wuffs_base__range_ie_u32__equals( - wuffs_base__range_ie_u32* r, - wuffs_base__range_ie_u32 s) { +static inline bool // +wuffs_base__range_ie_u32__equals(wuffs_base__range_ie_u32* r, + wuffs_base__range_ie_u32 s) { return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) || (wuffs_base__range_ie_u32__is_empty(r) && wuffs_base__range_ie_u32__is_empty(&s)); } -static inline bool wuffs_base__range_ie_u32__contains( - wuffs_base__range_ie_u32* r, - uint32_t x) { +static inline bool // +wuffs_base__range_ie_u32__contains(wuffs_base__range_ie_u32* r, uint32_t x) { return (r->min_incl <= x) && (x < r->max_excl); } -static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersect( - wuffs_base__range_ie_u32* r, - wuffs_base__range_ie_u32 s) { +static inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32__intersect(wuffs_base__range_ie_u32* r, + wuffs_base__range_ie_u32 s) { wuffs_base__range_ie_u32 t; t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl); t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl); return t; } -static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite( - wuffs_base__range_ie_u32* r, - wuffs_base__range_ie_u32 s) { +static inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32__unite(wuffs_base__range_ie_u32* r, + wuffs_base__range_ie_u32 s) { if (wuffs_base__range_ie_u32__is_empty(r)) { return s; } @@ -504,36 +530,40 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite( return t; } -static inline uint32_t wuffs_base__range_ie_u32__length( - wuffs_base__range_ie_u32* r) { +static inline uint32_t // +wuffs_base__range_ie_u32__length(wuffs_base__range_ie_u32* r) { return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl); } #ifdef __cplusplus -inline bool wuffs_base__range_ie_u32::is_empty() { +inline bool // +wuffs_base__range_ie_u32::is_empty() { return wuffs_base__range_ie_u32__is_empty(this); } -inline bool wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) { +inline bool // +wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) { return wuffs_base__range_ie_u32__equals(this, s); } -inline bool wuffs_base__range_ie_u32::contains(uint32_t x) { +inline bool // +wuffs_base__range_ie_u32::contains(uint32_t x) { return wuffs_base__range_ie_u32__contains(this, x); } -inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::intersect( - wuffs_base__range_ie_u32 s) { +inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) { return wuffs_base__range_ie_u32__intersect(this, s); } -inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::unite( - wuffs_base__range_ie_u32 s) { +inline wuffs_base__range_ie_u32 // +wuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) { return wuffs_base__range_ie_u32__unite(this, s); } -inline uint32_t wuffs_base__range_ie_u32::length() { +inline uint32_t // +wuffs_base__range_ie_u32::length() { return wuffs_base__range_ie_u32__length(this); } @@ -557,37 +587,36 @@ typedef struct wuffs_base__range_ii_u64__struct { } wuffs_base__range_ii_u64; -static inline bool wuffs_base__range_ii_u64__is_empty( - wuffs_base__range_ii_u64* r) { +static inline bool // +wuffs_base__range_ii_u64__is_empty(wuffs_base__range_ii_u64* r) { return r->min_incl > r->max_incl; } -static inline bool wuffs_base__range_ii_u64__equals( - wuffs_base__range_ii_u64* r, - wuffs_base__range_ii_u64 s) { +static inline bool // +wuffs_base__range_ii_u64__equals(wuffs_base__range_ii_u64* r, + wuffs_base__range_ii_u64 s) { return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) || (wuffs_base__range_ii_u64__is_empty(r) && wuffs_base__range_ii_u64__is_empty(&s)); } -static inline bool wuffs_base__range_ii_u64__contains( - wuffs_base__range_ii_u64* r, - uint64_t x) { +static inline bool // +wuffs_base__range_ii_u64__contains(wuffs_base__range_ii_u64* r, uint64_t x) { return (r->min_incl <= x) && (x <= r->max_incl); } -static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersect( - wuffs_base__range_ii_u64* r, - wuffs_base__range_ii_u64 s) { +static inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64__intersect(wuffs_base__range_ii_u64* r, + wuffs_base__range_ii_u64 s) { wuffs_base__range_ii_u64 t; t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl); t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl); return t; } -static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite( - wuffs_base__range_ii_u64* r, - wuffs_base__range_ii_u64 s) { +static inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64__unite(wuffs_base__range_ii_u64* r, + wuffs_base__range_ii_u64 s) { if (wuffs_base__range_ii_u64__is_empty(r)) { return s; } @@ -602,25 +631,28 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite( #ifdef __cplusplus -inline bool wuffs_base__range_ii_u64::is_empty() { +inline bool // +wuffs_base__range_ii_u64::is_empty() { return wuffs_base__range_ii_u64__is_empty(this); } -inline bool wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) { +inline bool // +wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) { return wuffs_base__range_ii_u64__equals(this, s); } -inline bool wuffs_base__range_ii_u64::contains(uint64_t x) { +inline bool // +wuffs_base__range_ii_u64::contains(uint64_t x) { return wuffs_base__range_ii_u64__contains(this, x); } -inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::intersect( - wuffs_base__range_ii_u64 s) { +inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64::intersect(wuffs_base__range_ii_u64 s) { return wuffs_base__range_ii_u64__intersect(this, s); } -inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::unite( - wuffs_base__range_ii_u64 s) { +inline wuffs_base__range_ii_u64 // +wuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) { return wuffs_base__range_ii_u64__unite(this, s); } @@ -645,37 +677,36 @@ typedef struct wuffs_base__range_ie_u64__struct { } wuffs_base__range_ie_u64; -static inline bool wuffs_base__range_ie_u64__is_empty( - wuffs_base__range_ie_u64* r) { +static inline bool // +wuffs_base__range_ie_u64__is_empty(wuffs_base__range_ie_u64* r) { return r->min_incl >= r->max_excl; } -static inline bool wuffs_base__range_ie_u64__equals( - wuffs_base__range_ie_u64* r, - wuffs_base__range_ie_u64 s) { +static inline bool // +wuffs_base__range_ie_u64__equals(wuffs_base__range_ie_u64* r, + wuffs_base__range_ie_u64 s) { return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) || (wuffs_base__range_ie_u64__is_empty(r) && wuffs_base__range_ie_u64__is_empty(&s)); } -static inline bool wuffs_base__range_ie_u64__contains( - wuffs_base__range_ie_u64* r, - uint64_t x) { +static inline bool // +wuffs_base__range_ie_u64__contains(wuffs_base__range_ie_u64* r, uint64_t x) { return (r->min_incl <= x) && (x < r->max_excl); } -static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersect( - wuffs_base__range_ie_u64* r, - wuffs_base__range_ie_u64 s) { +static inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64__intersect(wuffs_base__range_ie_u64* r, + wuffs_base__range_ie_u64 s) { wuffs_base__range_ie_u64 t; t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl); t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl); return t; } -static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite( - wuffs_base__range_ie_u64* r, - wuffs_base__range_ie_u64 s) { +static inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64__unite(wuffs_base__range_ie_u64* r, + wuffs_base__range_ie_u64 s) { if (wuffs_base__range_ie_u64__is_empty(r)) { return s; } @@ -688,36 +719,40 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite( return t; } -static inline uint64_t wuffs_base__range_ie_u64__length( - wuffs_base__range_ie_u64* r) { +static inline uint64_t // +wuffs_base__range_ie_u64__length(wuffs_base__range_ie_u64* r) { return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl); } #ifdef __cplusplus -inline bool wuffs_base__range_ie_u64::is_empty() { +inline bool // +wuffs_base__range_ie_u64::is_empty() { return wuffs_base__range_ie_u64__is_empty(this); } -inline bool wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) { +inline bool // +wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) { return wuffs_base__range_ie_u64__equals(this, s); } -inline bool wuffs_base__range_ie_u64::contains(uint64_t x) { +inline bool // +wuffs_base__range_ie_u64::contains(uint64_t x) { return wuffs_base__range_ie_u64__contains(this, x); } -inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::intersect( - wuffs_base__range_ie_u64 s) { +inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) { return wuffs_base__range_ie_u64__intersect(this, s); } -inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::unite( - wuffs_base__range_ie_u64 s) { +inline wuffs_base__range_ie_u64 // +wuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) { return wuffs_base__range_ie_u64__unite(this, s); } -inline uint64_t wuffs_base__range_ie_u64::length() { +inline uint64_t // +wuffs_base__range_ie_u64::length() { return wuffs_base__range_ie_u64__length(this); } @@ -752,29 +787,31 @@ typedef struct wuffs_base__rect_ii_u32__struct { } wuffs_base__rect_ii_u32; -static inline bool wuffs_base__rect_ii_u32__is_empty( - wuffs_base__rect_ii_u32* r) { +static inline bool // +wuffs_base__rect_ii_u32__is_empty(wuffs_base__rect_ii_u32* r) { return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y); } -static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r, - wuffs_base__rect_ii_u32 s) { +static inline bool // +wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r, + wuffs_base__rect_ii_u32 s) { return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y && r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) || (wuffs_base__rect_ii_u32__is_empty(r) && wuffs_base__rect_ii_u32__is_empty(&s)); } -static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r, - uint32_t x, - uint32_t y) { +static inline bool // +wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r, + uint32_t x, + uint32_t y) { return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) && (y <= r->max_incl_y); } -static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect( - wuffs_base__rect_ii_u32* r, - wuffs_base__rect_ii_u32 s) { +static inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32__intersect(wuffs_base__rect_ii_u32* r, + wuffs_base__rect_ii_u32 s) { wuffs_base__rect_ii_u32 t; t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x); t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y); @@ -783,9 +820,9 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect( return t; } -static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite( - wuffs_base__rect_ii_u32* r, - wuffs_base__rect_ii_u32 s) { +static inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32__unite(wuffs_base__rect_ii_u32* r, + wuffs_base__rect_ii_u32 s) { if (wuffs_base__rect_ii_u32__is_empty(r)) { return s; } @@ -802,25 +839,28 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite( #ifdef __cplusplus -inline bool wuffs_base__rect_ii_u32::is_empty() { +inline bool // +wuffs_base__rect_ii_u32::is_empty() { return wuffs_base__rect_ii_u32__is_empty(this); } -inline bool wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) { +inline bool // +wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) { return wuffs_base__rect_ii_u32__equals(this, s); } -inline bool wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) { +inline bool // +wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) { return wuffs_base__rect_ii_u32__contains(this, x, y); } -inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::intersect( - wuffs_base__rect_ii_u32 s) { +inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) { return wuffs_base__rect_ii_u32__intersect(this, s); } -inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::unite( - wuffs_base__rect_ii_u32 s) { +inline wuffs_base__rect_ii_u32 // +wuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) { return wuffs_base__rect_ii_u32__unite(this, s); } @@ -858,29 +898,31 @@ typedef struct wuffs_base__rect_ie_u32__struct { } wuffs_base__rect_ie_u32; -static inline bool wuffs_base__rect_ie_u32__is_empty( - wuffs_base__rect_ie_u32* r) { +static inline bool // +wuffs_base__rect_ie_u32__is_empty(wuffs_base__rect_ie_u32* r) { return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y); } -static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r, - wuffs_base__rect_ie_u32 s) { +static inline bool // +wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r, + wuffs_base__rect_ie_u32 s) { return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y && r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) || (wuffs_base__rect_ie_u32__is_empty(r) && wuffs_base__rect_ie_u32__is_empty(&s)); } -static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r, - uint32_t x, - uint32_t y) { +static inline bool // +wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r, + uint32_t x, + uint32_t y) { return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) && (y < r->max_excl_y); } -static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersect( - wuffs_base__rect_ie_u32* r, - wuffs_base__rect_ie_u32 s) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32__intersect(wuffs_base__rect_ie_u32* r, + wuffs_base__rect_ie_u32 s) { wuffs_base__rect_ie_u32 t; t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x); t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y); @@ -889,9 +931,9 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersect( return t; } -static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite( - wuffs_base__rect_ie_u32* r, - wuffs_base__rect_ie_u32 s) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32__unite(wuffs_base__rect_ie_u32* r, + wuffs_base__rect_ie_u32 s) { if (wuffs_base__rect_ie_u32__is_empty(r)) { return s; } @@ -906,45 +948,50 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite( return t; } -static inline uint32_t wuffs_base__rect_ie_u32__width( - wuffs_base__rect_ie_u32* r) { +static inline uint32_t // +wuffs_base__rect_ie_u32__width(wuffs_base__rect_ie_u32* r) { return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x); } -static inline uint32_t wuffs_base__rect_ie_u32__height( - wuffs_base__rect_ie_u32* r) { +static inline uint32_t // +wuffs_base__rect_ie_u32__height(wuffs_base__rect_ie_u32* r) { return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y); } #ifdef __cplusplus -inline bool wuffs_base__rect_ie_u32::is_empty() { +inline bool // +wuffs_base__rect_ie_u32::is_empty() { return wuffs_base__rect_ie_u32__is_empty(this); } -inline bool wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) { +inline bool // +wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) { return wuffs_base__rect_ie_u32__equals(this, s); } -inline bool wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) { +inline bool // +wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) { return wuffs_base__rect_ie_u32__contains(this, x, y); } -inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::intersect( - wuffs_base__rect_ie_u32 s) { +inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) { return wuffs_base__rect_ie_u32__intersect(this, s); } -inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::unite( - wuffs_base__rect_ie_u32 s) { +inline wuffs_base__rect_ie_u32 // +wuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) { return wuffs_base__rect_ie_u32__unite(this, s); } -inline uint32_t wuffs_base__rect_ie_u32::width() { +inline uint32_t // +wuffs_base__rect_ie_u32::width() { return wuffs_base__rect_ie_u32__width(this); } -inline uint32_t wuffs_base__rect_ie_u32::height() { +inline uint32_t // +wuffs_base__rect_ie_u32::height() { return wuffs_base__rect_ie_u32__height(this); } @@ -999,7 +1046,8 @@ typedef struct wuffs_base__io_buffer__struct { // wuffs_base__io_buffer__compact moves any written but unread bytes to the // start of the buffer. -static inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { +static inline void // +wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { if (!buf || (buf->ri == 0)) { return; } @@ -1011,15 +1059,15 @@ static inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) { buf->ri = 0; } -static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( - wuffs_base__io_buffer* buf) { +static inline wuffs_base__io_reader // +wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) { wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); ret.private_impl.buf = buf; return ret; } -static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( - wuffs_base__io_buffer* buf) { +static inline wuffs_base__io_writer // +wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) { wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); ret.private_impl.buf = buf; return ret; @@ -1027,15 +1075,18 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( #ifdef __cplusplus -inline void wuffs_base__io_buffer__struct::compact() { +inline void // +wuffs_base__io_buffer__struct::compact() { wuffs_base__io_buffer__compact(this); } -inline wuffs_base__io_reader wuffs_base__io_buffer__struct::reader() { +inline wuffs_base__io_reader // +wuffs_base__io_buffer__struct::reader() { return wuffs_base__io_buffer__reader(this); } -inline wuffs_base__io_writer wuffs_base__io_buffer__struct::writer() { +inline wuffs_base__io_writer // +wuffs_base__io_buffer__struct::writer() { return wuffs_base__io_buffer__writer(this); } @@ -1201,20 +1252,20 @@ typedef uint32_t wuffs_base__pixel_format; #define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888) #define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888) -static inline bool wuffs_base__pixel_format__is_valid( - wuffs_base__pixel_format f) { +static inline bool // +wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) { return f != 0; } -static inline bool wuffs_base__pixel_format__is_indexed( - wuffs_base__pixel_format f) { +static inline bool // +wuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) { return ((f >> 16) & 0x0F) != 0; } #define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 -static inline uint32_t wuffs_base__pixel_format__num_planes( - wuffs_base__pixel_format f) { +static inline uint32_t // +wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) { return f ? (((f >> 20) & 0x03) + 1) : 0; } @@ -1274,30 +1325,30 @@ typedef uint32_t wuffs_base__pixel_subsampling; #define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \ ((wuffs_base__pixel_subsampling)0x212100) -static inline uint32_t wuffs_base__pixel_subsampling__bias_x( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__bias_x(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 6; return (s >> shift) & 0x03; } -static inline uint32_t wuffs_base__pixel_subsampling__shift_x( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__shift_x(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 4; return (s >> shift) & 0x03; } -static inline uint32_t wuffs_base__pixel_subsampling__bias_y( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 2; return (s >> shift) & 0x03; } -static inline uint32_t wuffs_base__pixel_subsampling__shift_y( - wuffs_base__pixel_subsampling s, - uint32_t plane) { +static inline uint32_t // +wuffs_base__pixel_subsampling__shift_y(wuffs_base__pixel_subsampling s, + uint32_t plane) { uint32_t shift = ((plane & 0x03) * 8) + 0; return (s >> shift) & 0x03; } @@ -1338,14 +1389,14 @@ typedef struct { } wuffs_base__image_config; // TODO: Should this function return bool? An error type? -static inline void wuffs_base__image_config__initialize( - wuffs_base__image_config* c, - wuffs_base__pixel_format pixfmt, - wuffs_base__pixel_subsampling pixsub, - uint32_t width, - uint32_t height, - uint32_t num_loops, - bool first_frame_is_opaque) { +static inline void // +wuffs_base__image_config__initialize(wuffs_base__image_config* c, + wuffs_base__pixel_format pixfmt, + wuffs_base__pixel_subsampling pixsub, + uint32_t width, + uint32_t height, + uint32_t num_loops, + bool first_frame_is_opaque) { if (!c) { return; } @@ -1365,30 +1416,30 @@ static inline void wuffs_base__image_config__initialize( *c = ((wuffs_base__image_config){}); } -static inline void wuffs_base__image_config__invalidate( - wuffs_base__image_config* c) { +static inline void // +wuffs_base__image_config__invalidate(wuffs_base__image_config* c) { if (c) { *c = ((wuffs_base__image_config){}); } } -static inline bool wuffs_base__image_config__is_valid( - wuffs_base__image_config* c) { +static inline bool // +wuffs_base__image_config__is_valid(wuffs_base__image_config* c) { return c && c->private_impl.pixfmt; } -static inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format( - wuffs_base__image_config* c) { +static inline wuffs_base__pixel_format // +wuffs_base__image_config__pixel_format(wuffs_base__image_config* c) { return c ? c->private_impl.pixfmt : 0; } -static inline wuffs_base__pixel_subsampling +static inline wuffs_base__pixel_subsampling // wuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) { return c ? c->private_impl.pixsub : 0; } -static inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds( - wuffs_base__image_config* c) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__image_config__bounds(wuffs_base__image_config* c) { return c ? ((wuffs_base__rect_ie_u32){ .min_incl_x = 0, .min_incl_y = 0, @@ -1398,31 +1449,31 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds( : ((wuffs_base__rect_ie_u32){}); } -static inline uint32_t wuffs_base__image_config__width( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__width(wuffs_base__image_config* c) { return c ? c->private_impl.width : 0; } -static inline uint32_t wuffs_base__image_config__height( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__height(wuffs_base__image_config* c) { return c ? c->private_impl.height : 0; } -static inline uint32_t wuffs_base__image_config__num_loops( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__num_loops(wuffs_base__image_config* c) { return c ? c->private_impl.num_loops : 0; } -static inline uint32_t wuffs_base__image_config__first_frame_is_opaque( - wuffs_base__image_config* c) { +static inline uint32_t // +wuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) { return c ? c->private_impl.first_frame_is_opaque : false; } // TODO: this is the right API for planar (not packed) pixbufs? Should it allow // decoding into a color model different from the format's intrinsic one? For // example, decoding a JPEG image straight to RGBA instead of to YCbCr? -static inline size_t wuffs_base__image_config__pixbuf_size( - wuffs_base__image_config* c) { +static inline size_t // +wuffs_base__image_config__pixbuf_size(wuffs_base__image_config* c) { if (c) { uint64_t wh = ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); @@ -1434,55 +1485,64 @@ static inline size_t wuffs_base__image_config__pixbuf_size( #ifdef __cplusplus -inline void wuffs_base__image_config::initialize( - wuffs_base__pixel_format pixfmt, - wuffs_base__pixel_subsampling pixsub, - uint32_t width, - uint32_t height, - uint32_t num_loops, - bool first_frame_is_opaque) { +inline void // +wuffs_base__image_config::initialize(wuffs_base__pixel_format pixfmt, + wuffs_base__pixel_subsampling pixsub, + uint32_t width, + uint32_t height, + uint32_t num_loops, + bool first_frame_is_opaque) { wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height, num_loops, first_frame_is_opaque); } -inline void wuffs_base__image_config::invalidate() { +inline void // +wuffs_base__image_config::invalidate() { wuffs_base__image_config__invalidate(this); } -inline bool wuffs_base__image_config::is_valid() { +inline bool // +wuffs_base__image_config::is_valid() { return wuffs_base__image_config__is_valid(this); } -inline wuffs_base__pixel_format wuffs_base__image_config::pixel_format() { +inline wuffs_base__pixel_format // +wuffs_base__image_config::pixel_format() { return wuffs_base__image_config__pixel_format(this); } -inline wuffs_base__pixel_subsampling +inline wuffs_base__pixel_subsampling // wuffs_base__image_config::pixel_subsampling() { return wuffs_base__image_config__pixel_subsampling(this); } -inline wuffs_base__rect_ie_u32 wuffs_base__image_config::bounds() { +inline wuffs_base__rect_ie_u32 // +wuffs_base__image_config::bounds() { return wuffs_base__image_config__bounds(this); } -inline uint32_t wuffs_base__image_config::width() { +inline uint32_t // +wuffs_base__image_config::width() { return wuffs_base__image_config__width(this); } -inline uint32_t wuffs_base__image_config::height() { +inline uint32_t // +wuffs_base__image_config::height() { return wuffs_base__image_config__height(this); } -inline uint32_t wuffs_base__image_config::num_loops() { +inline uint32_t // +wuffs_base__image_config::num_loops() { return wuffs_base__image_config__num_loops(this); } -inline uint32_t wuffs_base__image_config::first_frame_is_opaque() { +inline uint32_t // +wuffs_base__image_config::first_frame_is_opaque() { return wuffs_base__image_config__first_frame_is_opaque(this); } -inline size_t wuffs_base__image_config::pixbuf_size() { +inline size_t // +wuffs_base__image_config::pixbuf_size() { return wuffs_base__image_config__pixbuf_size(this); } @@ -1548,10 +1608,10 @@ typedef struct { } wuffs_base__image_buffer; -static inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf( - wuffs_base__image_buffer* b, - wuffs_base__image_config config, - wuffs_base__pixel_buffer pixbuf) { +static inline wuffs_base__status // +wuffs_base__image_buffer__set_from_pixbuf(wuffs_base__image_buffer* b, + wuffs_base__image_config config, + wuffs_base__pixel_buffer pixbuf) { if (!b) { return WUFFS_BASE__ERROR_BAD_RECEIVER; } @@ -1561,10 +1621,10 @@ static inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf( return WUFFS_BASE__STATUS_OK; } -static inline wuffs_base__status wuffs_base__image_buffer__set_from_slice( - wuffs_base__image_buffer* b, - wuffs_base__image_config config, - wuffs_base__slice_u8 pixbuf_memory) { +static inline wuffs_base__status // +wuffs_base__image_buffer__set_from_slice(wuffs_base__image_buffer* b, + wuffs_base__image_config config, + wuffs_base__slice_u8 pixbuf_memory) { if (!b) { return WUFFS_BASE__ERROR_BAD_RECEIVER; } @@ -1585,13 +1645,13 @@ static inline wuffs_base__status wuffs_base__image_buffer__set_from_slice( } // The palette argument is ignored unless its length is exactly 1024. -static inline void wuffs_base__image_buffer__update( - wuffs_base__image_buffer* b, - wuffs_base__rect_ie_u32 dirty_rect, - wuffs_base__flicks duration, - bool blend, - wuffs_base__animation_disposal disposal, - wuffs_base__slice_u8 palette) { +static inline void // +wuffs_base__image_buffer__update(wuffs_base__image_buffer* b, + wuffs_base__rect_ie_u32 dirty_rect, + wuffs_base__flicks duration, + bool blend, + wuffs_base__animation_disposal disposal, + wuffs_base__slice_u8 palette) { if (!b) { return; } @@ -1613,38 +1673,38 @@ static inline void wuffs_base__image_buffer__update( } // wuffs_base__image_config returns the overall configuration for this frame. -static inline wuffs_base__image_config* wuffs_base__image_buffer__image_config( - wuffs_base__image_buffer* b) { +static inline wuffs_base__image_config* // +wuffs_base__image_buffer__image_config(wuffs_base__image_buffer* b) { return b ? &b->private_impl.config : NULL; } -static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__bounds( - wuffs_base__image_buffer* b) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer__bounds(wuffs_base__image_buffer* b) { return b ? wuffs_base__image_config__bounds(&b->private_impl.config) : ((wuffs_base__rect_ie_u32){}); } -static inline uint32_t wuffs_base__image_buffer__width( - wuffs_base__image_buffer* b) { +static inline uint32_t // +wuffs_base__image_buffer__width(wuffs_base__image_buffer* b) { return b ? wuffs_base__image_config__width(&b->private_impl.config) : 0; } -static inline uint32_t wuffs_base__image_buffer__height( - wuffs_base__image_buffer* b) { +static inline uint32_t // +wuffs_base__image_buffer__height(wuffs_base__image_buffer* b) { return b ? wuffs_base__image_config__height(&b->private_impl.config) : 0; } // wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of // this frame's pixels differs from the previous frame. -static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect( - wuffs_base__image_buffer* b) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer__dirty_rect(wuffs_base__image_buffer* b) { return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){}); } // wuffs_base__image_buffer__duration returns the amount of time to display // this frame. Zero means to display forever - a still (non-animated) image. -static inline wuffs_base__flicks wuffs_base__image_buffer__duration( - wuffs_base__image_buffer* b) { +static inline wuffs_base__flicks // +wuffs_base__image_buffer__duration(wuffs_base__image_buffer* b) { return b ? b->private_impl.duration : 0; } @@ -1653,38 +1713,37 @@ static inline wuffs_base__flicks wuffs_base__image_buffer__duration( // // In Porter-Duff compositing operator terminology, false means "src" and true // means "src over dst". -static inline bool wuffs_base__image_buffer__blend( - wuffs_base__image_buffer* b) { +static inline bool // +wuffs_base__image_buffer__blend(wuffs_base__image_buffer* b) { return b && b->private_impl.blend; } // wuffs_base__image_buffer__disposal returns, for an animated image, how to // dispose of this frame after displaying it. -static inline wuffs_base__animation_disposal wuffs_base__image_buffer__disposal( - wuffs_base__image_buffer* b) { +static inline wuffs_base__animation_disposal // +wuffs_base__image_buffer__disposal(wuffs_base__image_buffer* b) { return b ? b->private_impl.disposal : 0; } // wuffs_base__image_buffer__palette_changed returns whether this frame's // palette differs from the previous frame. It is conservative and may return // false positives (but never false negatives). -static inline bool wuffs_base__image_buffer__palette_changed( - wuffs_base__image_buffer* b) { +static inline bool // +wuffs_base__image_buffer__palette_changed(wuffs_base__image_buffer* b) { return b && b->private_impl.palette_changed; } // wuffs_base__image_buffer__palette returns the palette that the pixel data // can index. The backing array is inside b and has length 1024. -static inline wuffs_base__slice_u8 wuffs_base__image_buffer__palette( - wuffs_base__image_buffer* b) { +static inline wuffs_base__slice_u8 // +wuffs_base__image_buffer__palette(wuffs_base__image_buffer* b) { return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette, .len = 1024}) : ((wuffs_base__slice_u8){}); } -static inline wuffs_base__table_u8 wuffs_base__image_buffer__plane( - wuffs_base__image_buffer* b, - uint32_t p) { +static inline wuffs_base__table_u8 // +wuffs_base__image_buffer__plane(wuffs_base__image_buffer* b, uint32_t p) { return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) ? b->private_impl.pixbuf.planes[p] : ((wuffs_base__table_u8){}); @@ -1692,69 +1751,80 @@ static inline wuffs_base__table_u8 wuffs_base__image_buffer__plane( #ifdef __cplusplus -inline wuffs_base__status wuffs_base__image_buffer::set_from_pixbuf( - wuffs_base__image_config config, - wuffs_base__pixel_buffer pixbuf) { +inline wuffs_base__status // +wuffs_base__image_buffer::set_from_pixbuf(wuffs_base__image_config config, + wuffs_base__pixel_buffer pixbuf) { return wuffs_base__image_buffer__set_from_pixbuf(this, config, pixbuf); } -inline wuffs_base__status wuffs_base__image_buffer::set_from_slice( - wuffs_base__image_config config, - wuffs_base__slice_u8 pixbuf_memory) { +inline wuffs_base__status // +wuffs_base__image_buffer::set_from_slice(wuffs_base__image_config config, + wuffs_base__slice_u8 pixbuf_memory) { return wuffs_base__image_buffer__set_from_slice(this, config, pixbuf_memory); } -inline void wuffs_base__image_buffer::update( - wuffs_base__rect_ie_u32 dirty_rect, - wuffs_base__flicks duration, - bool blend, - wuffs_base__animation_disposal disposal, - wuffs_base__slice_u8 palette) { +inline void // +wuffs_base__image_buffer::update(wuffs_base__rect_ie_u32 dirty_rect, + wuffs_base__flicks duration, + bool blend, + wuffs_base__animation_disposal disposal, + wuffs_base__slice_u8 palette) { wuffs_base__image_buffer__update(this, dirty_rect, duration, blend, disposal, palette); } -inline wuffs_base__image_config* wuffs_base__image_buffer::image_config() { +inline wuffs_base__image_config* // +wuffs_base__image_buffer::image_config() { return wuffs_base__image_buffer__image_config(this); } -inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::bounds() { +inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer::bounds() { return wuffs_base__image_buffer__bounds(this); } -inline uint32_t wuffs_base__image_buffer::width() { +inline uint32_t // +wuffs_base__image_buffer::width() { return wuffs_base__image_buffer__width(this); } -inline uint32_t wuffs_base__image_buffer::height() { +inline uint32_t // +wuffs_base__image_buffer::height() { return wuffs_base__image_buffer__height(this); } -inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::dirty_rect() { +inline wuffs_base__rect_ie_u32 // +wuffs_base__image_buffer::dirty_rect() { return wuffs_base__image_buffer__dirty_rect(this); } -inline wuffs_base__flicks wuffs_base__image_buffer::duration() { +inline wuffs_base__flicks // +wuffs_base__image_buffer::duration() { return wuffs_base__image_buffer__duration(this); } -inline bool wuffs_base__image_buffer::blend() { +inline bool // +wuffs_base__image_buffer::blend() { return wuffs_base__image_buffer__blend(this); } -inline wuffs_base__animation_disposal wuffs_base__image_buffer::disposal() { +inline wuffs_base__animation_disposal // +wuffs_base__image_buffer::disposal() { return wuffs_base__image_buffer__disposal(this); } -inline bool wuffs_base__image_buffer::palette_changed() { +inline bool // +wuffs_base__image_buffer::palette_changed() { return wuffs_base__image_buffer__palette_changed(this); } -inline wuffs_base__slice_u8 wuffs_base__image_buffer::palette() { +inline wuffs_base__slice_u8 // +wuffs_base__image_buffer::palette() { return wuffs_base__image_buffer__palette(this); } -inline wuffs_base__table_u8 wuffs_base__image_buffer::plane(uint32_t p) { +inline wuffs_base__table_u8 // +wuffs_base__image_buffer::plane(uint32_t p) { return wuffs_base__image_buffer__plane(this, p); } @@ -2757,90 +2827,106 @@ extern "C" { // inline attribute to guide optimizations such as inlining, to avoid the // -Wunused-function warning, and we like to compile with -Wall -Werror. -static inline wuffs_base__empty_struct wuffs_base__return_empty_struct() { +static inline wuffs_base__empty_struct // +wuffs_base__return_empty_struct() { return ((wuffs_base__empty_struct){}); } // ---------------- Numeric Types -static inline uint8_t wuffs_base__load_u8be(uint8_t* p) { +static inline uint8_t // +wuffs_base__load_u8be(uint8_t* p) { return p[0]; } -static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { +static inline uint16_t // +wuffs_base__load_u16be(uint8_t* p) { return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); } -static inline uint16_t wuffs_base__load_u16le(uint8_t* p) { +static inline uint16_t // +wuffs_base__load_u16le(uint8_t* p) { return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8); } -static inline uint32_t wuffs_base__load_u24be(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u24be(uint8_t* p) { return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 0); } -static inline uint32_t wuffs_base__load_u24le(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u24le(uint8_t* p) { return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 16); } -static inline uint32_t wuffs_base__load_u32be(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u32be(uint8_t* p) { return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) | ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0); } -static inline uint32_t wuffs_base__load_u32le(uint8_t* p) { +static inline uint32_t // +wuffs_base__load_u32le(uint8_t* p) { return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); } -static inline uint64_t wuffs_base__load_u40be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u40be(uint8_t* p) { return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) | ((uint64_t)(p[4]) << 0); } -static inline uint64_t wuffs_base__load_u40le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u40le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32); } -static inline uint64_t wuffs_base__load_u48be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u48be(uint8_t* p) { return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) | ((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) | ((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0); } -static inline uint64_t wuffs_base__load_u48le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u48le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40); } -static inline uint64_t wuffs_base__load_u56be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u56be(uint8_t* p) { return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) | ((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) | ((uint64_t)(p[6]) << 0); } -static inline uint64_t wuffs_base__load_u56le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u56le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | ((uint64_t)(p[6]) << 48); } -static inline uint64_t wuffs_base__load_u64be(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u64be(uint8_t* p) { return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) | ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) | ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) | ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0); } -static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { +static inline uint64_t // +wuffs_base__load_u64le(uint8_t* p) { return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | @@ -2849,47 +2935,55 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { // -------- -static inline void wuffs_base__store_u8be(uint8_t* p, uint8_t x) { +static inline void // +wuffs_base__store_u8be(uint8_t* p, uint8_t x) { p[0] = x; } -static inline void wuffs_base__store_u16be(uint8_t* p, uint16_t x) { +static inline void // +wuffs_base__store_u16be(uint8_t* p, uint16_t x) { p[0] = x >> 8; p[1] = x >> 0; } -static inline void wuffs_base__store_u16le(uint8_t* p, uint16_t x) { +static inline void // +wuffs_base__store_u16le(uint8_t* p, uint16_t x) { p[0] = x >> 0; p[1] = x >> 8; } -static inline void wuffs_base__store_u24be(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u24be(uint8_t* p, uint32_t x) { p[0] = x >> 16; p[1] = x >> 8; p[2] = x >> 0; } -static inline void wuffs_base__store_u24le(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u24le(uint8_t* p, uint32_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; } -static inline void wuffs_base__store_u32be(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u32be(uint8_t* p, uint32_t x) { p[0] = x >> 24; p[1] = x >> 16; p[2] = x >> 8; p[3] = x >> 0; } -static inline void wuffs_base__store_u32le(uint8_t* p, uint32_t x) { +static inline void // +wuffs_base__store_u32le(uint8_t* p, uint32_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; p[3] = x >> 24; } -static inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u40be(uint8_t* p, uint64_t x) { p[0] = x >> 32; p[1] = x >> 24; p[2] = x >> 16; @@ -2897,7 +2991,8 @@ static inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) { p[4] = x >> 0; } -static inline void wuffs_base__store_u40le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u40le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -2905,7 +3000,8 @@ static inline void wuffs_base__store_u40le(uint8_t* p, uint64_t x) { p[4] = x >> 32; } -static inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u48be(uint8_t* p, uint64_t x) { p[0] = x >> 40; p[1] = x >> 32; p[2] = x >> 24; @@ -2914,7 +3010,8 @@ static inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) { p[5] = x >> 0; } -static inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u48le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -2923,7 +3020,8 @@ static inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) { p[5] = x >> 40; } -static inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u56be(uint8_t* p, uint64_t x) { p[0] = x >> 48; p[1] = x >> 40; p[2] = x >> 32; @@ -2933,7 +3031,8 @@ static inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) { p[6] = x >> 0; } -static inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u56le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -2943,7 +3042,8 @@ static inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) { p[6] = x >> 48; } -static inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u64be(uint8_t* p, uint64_t x) { p[0] = x >> 56; p[1] = x >> 48; p[2] = x >> 40; @@ -2954,7 +3054,8 @@ static inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) { p[7] = x >> 0; } -static inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) { +static inline void // +wuffs_base__store_u64le(uint8_t* p, uint64_t x) { p[0] = x >> 0; p[1] = x >> 8; p[2] = x >> 16; @@ -2967,43 +3068,50 @@ static inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) { // -------- -static inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { +static inline void // +wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { *x = wuffs_base__u8__sat_add(*x, y); } -static inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { +static inline void // +wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { *x = wuffs_base__u8__sat_sub(*x, y); } -static inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { +static inline void // +wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { *x = wuffs_base__u16__sat_add(*x, y); } -static inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { +static inline void // +wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { *x = wuffs_base__u16__sat_sub(*x, y); } -static inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { +static inline void // +wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { *x = wuffs_base__u32__sat_add(*x, y); } -static inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { +static inline void // +wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { *x = wuffs_base__u32__sat_sub(*x, y); } -static inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { +static inline void // +wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { *x = wuffs_base__u64__sat_add(*x, y); } -static inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { +static inline void // +wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { *x = wuffs_base__u64__sat_sub(*x, y); } // ---------------- Slices and Tables -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( - wuffs_base__slice_u8 s, - uint64_t i) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) { if ((i <= SIZE_MAX) && (i <= s.len)) { return ((wuffs_base__slice_u8){ .ptr = s.ptr + i, @@ -3013,19 +3121,18 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( return ((wuffs_base__slice_u8){}); } -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j( - wuffs_base__slice_u8 s, - uint64_t j) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) { if ((j <= SIZE_MAX) && (j <= s.len)) { return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j}); } return ((wuffs_base__slice_u8){}); } -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij( - wuffs_base__slice_u8 s, - uint64_t i, - uint64_t j) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s, + uint64_t i, + uint64_t j) { if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) { return ((wuffs_base__slice_u8){ .ptr = s.ptr + i, @@ -3036,9 +3143,8 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij( } // wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s. -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix( - wuffs_base__slice_u8 s, - uint64_t up_to) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) { if ((uint64_t)(s.len) > up_to) { s.len = up_to; } @@ -3046,9 +3152,8 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix( } // wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s. -static inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix( - wuffs_base__slice_u8 s, - uint64_t up_to) { +static inline wuffs_base__slice_u8 // +wuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) { if ((uint64_t)(s.len) > up_to) { s.ptr += (uint64_t)(s.len) - up_to; s.len = up_to; @@ -3061,9 +3166,9 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix( // // Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty // slice) is valid and results in a no-op. -static inline uint64_t wuffs_base__slice_u8__copy_from_slice( - wuffs_base__slice_u8 dst, - wuffs_base__slice_u8 src) { +static inline uint64_t // +wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { size_t length = dst.len < src.len ? dst.len : src.len; if (length > 0) { memmove(dst.ptr, src.ptr, length); @@ -3073,9 +3178,8 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice( // -------- -static inline wuffs_base__slice_u8 wuffs_base__table_u8__row( - wuffs_base__table_u8 t, - uint32_t y) { +static inline wuffs_base__slice_u8 // +wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) { if (y < t.height) { return ((wuffs_base__slice_u8){ .ptr = t.ptr + (t.stride * y), @@ -3087,52 +3191,52 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row( // ---------------- Utility -static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32( - wuffs_base__utility* ignored, - uint32_t min_incl, - uint32_t max_incl) { +static inline wuffs_base__range_ii_u32 // +wuffs_base__utility__make_range_ii_u32(wuffs_base__utility* ignored, + uint32_t min_incl, + uint32_t max_incl) { return ((wuffs_base__range_ii_u32){ .min_incl = min_incl, .max_incl = max_incl, }); } -static inline wuffs_base__range_ie_u32 wuffs_base__utility__make_range_ie_u32( - wuffs_base__utility* ignored, - uint32_t min_incl, - uint32_t max_excl) { +static inline wuffs_base__range_ie_u32 // +wuffs_base__utility__make_range_ie_u32(wuffs_base__utility* ignored, + uint32_t min_incl, + uint32_t max_excl) { return ((wuffs_base__range_ie_u32){ .min_incl = min_incl, .max_excl = max_excl, }); } -static inline wuffs_base__range_ii_u64 wuffs_base__utility__make_range_ii_u64( - wuffs_base__utility* ignored, - uint64_t min_incl, - uint64_t max_incl) { +static inline wuffs_base__range_ii_u64 // +wuffs_base__utility__make_range_ii_u64(wuffs_base__utility* ignored, + uint64_t min_incl, + uint64_t max_incl) { return ((wuffs_base__range_ii_u64){ .min_incl = min_incl, .max_incl = max_incl, }); } -static inline wuffs_base__range_ie_u64 wuffs_base__utility__make_range_ie_u64( - wuffs_base__utility* ignored, - uint64_t min_incl, - uint64_t max_excl) { +static inline wuffs_base__range_ie_u64 // +wuffs_base__utility__make_range_ie_u64(wuffs_base__utility* ignored, + uint64_t min_incl, + uint64_t max_excl) { return ((wuffs_base__range_ie_u64){ .min_incl = min_incl, .max_excl = max_excl, }); } -static inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32( - wuffs_base__utility* ignored, - uint32_t min_incl_x, - uint32_t min_incl_y, - uint32_t max_incl_x, - uint32_t max_incl_y) { +static inline wuffs_base__rect_ii_u32 // +wuffs_base__utility__make_rect_ii_u32(wuffs_base__utility* ignored, + uint32_t min_incl_x, + uint32_t min_incl_y, + uint32_t max_incl_x, + uint32_t max_incl_y) { return ((wuffs_base__rect_ii_u32){ .min_incl_x = min_incl_x, .min_incl_y = min_incl_y, @@ -3141,12 +3245,12 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32( }); } -static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32( - wuffs_base__utility* ignored, - uint32_t min_incl_x, - uint32_t min_incl_y, - uint32_t max_excl_x, - uint32_t max_excl_y) { +static inline wuffs_base__rect_ie_u32 // +wuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored, + uint32_t min_incl_x, + uint32_t min_incl_y, + uint32_t max_excl_x, + uint32_t max_excl_y) { return ((wuffs_base__rect_ie_u32){ .min_incl_x = min_incl_x, .min_incl_y = min_incl_y, @@ -3157,17 +3261,20 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32( // ---------------- I/O -static inline bool wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { +static inline bool // +wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) { return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) && (buf.wi >= buf.ri); } -static inline bool wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) { +static inline bool // +wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.bounds[1]); } -static inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { +static inline bool // +wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) bounds. @@ -3178,7 +3285,8 @@ static inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) { (o.private_impl.bounds[1] == NULL)); } -static inline bool wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { +static inline bool // +wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { wuffs_base__io_buffer* buf = o.private_impl.buf; // Note: if making this function public (i.e. moving it to base-header.h), it // also needs to allow NULL (i.e. implicit, callee-calculated) bounds. @@ -3189,12 +3297,12 @@ static inline bool wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) { (o.private_impl.bounds[1] == NULL)); } -static inline uint32_t wuffs_base__io_writer__copy_n_from_history( - uint8_t** ptr_ptr, - uint8_t* start, - uint8_t* end, - uint32_t length, - uint32_t distance) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr, + uint8_t* start, + uint8_t* end, + uint32_t length, + uint32_t distance) { if (!distance) { return 0; } @@ -3237,12 +3345,12 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_history( // - distance > 0 // - distance <= (*ptr_ptr - start) // - length <= (end - *ptr_ptr) -static inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast( - uint8_t** ptr_ptr, - uint8_t* start, - uint8_t* end, - uint32_t length, - uint32_t distance) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr, + uint8_t* start, + uint8_t* end, + uint32_t length, + uint32_t distance) { uint8_t* ptr = *ptr_ptr; start = ptr - distance; uint32_t n = length; @@ -3258,12 +3366,12 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast( return length; } -static inline uint32_t wuffs_base__io_writer__copy_n_from_reader( - uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, - uint32_t length, - uint8_t** ptr_ioptr_r, - uint8_t* iobounds1_r) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w, + uint8_t* iobounds1_w, + uint32_t length, + uint8_t** ptr_ioptr_r, + uint8_t* iobounds1_r) { uint8_t* ioptr_w = *ptr_ioptr_w; size_t n = length; if (n > ((size_t)(iobounds1_w - ioptr_w))) { @@ -3281,10 +3389,10 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_reader( return n; } -static inline uint64_t wuffs_base__io_writer__copy_from_slice( - uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, - wuffs_base__slice_u8 src) { +static inline uint64_t // +wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w, + uint8_t* iobounds1_w, + wuffs_base__slice_u8 src) { uint8_t* ioptr_w = *ptr_ioptr_w; size_t n = src.len; if (n > ((size_t)(iobounds1_w - ioptr_w))) { @@ -3297,11 +3405,11 @@ static inline uint64_t wuffs_base__io_writer__copy_from_slice( return n; } -static inline uint32_t wuffs_base__io_writer__copy_n_from_slice( - uint8_t** ptr_ioptr_w, - uint8_t* iobounds1_w, - uint32_t length, - wuffs_base__slice_u8 src) { +static inline uint32_t // +wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w, + uint8_t* iobounds1_w, + uint32_t length, + wuffs_base__slice_u8 src) { uint8_t* ioptr_w = *ptr_ioptr_w; size_t n = src.len; if (n > length) { @@ -3317,29 +3425,28 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_slice( return n; } -static inline wuffs_base__empty_struct wuffs_base__io_reader__set_limit( - wuffs_base__io_reader* o, - uint8_t* ioptr_r, - uint64_t limit) { +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, + uint8_t* ioptr_r, + uint64_t limit) { if (o && (((size_t)(o->private_impl.bounds[1] - ioptr_r)) > limit)) { o->private_impl.bounds[1] = ioptr_r + limit; } return ((wuffs_base__empty_struct){}); } -static inline wuffs_base__empty_struct wuffs_base__io_reader__set_mark( - wuffs_base__io_reader* o, - uint8_t* mark) { +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { o->private_impl.bounds[0] = mark; return ((wuffs_base__empty_struct){}); } -static inline wuffs_base__empty_struct wuffs_base__io_writer__set( - wuffs_base__io_writer* o, - wuffs_base__io_buffer* b, - uint8_t** ioptr1_ptr, - uint8_t** ioptr2_ptr, - wuffs_base__slice_u8 s) { +static inline wuffs_base__empty_struct // +wuffs_base__io_writer__set(wuffs_base__io_writer* o, + wuffs_base__io_buffer* b, + uint8_t** ioptr1_ptr, + uint8_t** ioptr2_ptr, + wuffs_base__slice_u8 s) { b->ptr = s.ptr; b->len = s.len; b->wi = 0; @@ -3353,9 +3460,8 @@ static inline wuffs_base__empty_struct wuffs_base__io_writer__set( return ((wuffs_base__empty_struct){}); } -static inline wuffs_base__empty_struct wuffs_base__io_writer__set_mark( - wuffs_base__io_writer* o, - uint8_t* mark) { +static inline wuffs_base__empty_struct // +wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) { o->private_impl.bounds[0] = mark; return ((wuffs_base__empty_struct){}); } @@ -3424,7 +3530,8 @@ static const uint16_t wuffs_base__status__string_offsets[] = { 0x00B9, 0x00D9, 0x00E6, 0x00FA, }; -const char* wuffs_base__status__string(wuffs_base__status s) { +const char* // +wuffs_base__status__string(wuffs_base__status s) { uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)]; return o ? wuffs_base__status__string_data + o : "unknown status"; }