diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 82ebb67e..1b068775 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -135,20 +135,6 @@ bool color_flag = false; bool quirk_honor_background_color_flag = false; const int stdout_fd = 1; -static inline uint32_t // -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 void // -store_u32le(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); -} - void // restore_background(wuffs_base__pixel_buffer* pb, wuffs_base__rect_ie_u32 bounds, @@ -159,7 +145,7 @@ restore_background(wuffs_base__pixel_buffer* pb, size_t x; uint8_t* d = curr_dst_buffer + (y * width4) + (bounds.min_incl_x * 4); for (x = bounds.min_incl_x; x < bounds.max_excl_x; x++) { - store_u32le(d, background_color); + wuffs_base__store_u32le__no_bounds_check(d, background_color); d += sizeof(wuffs_base__color_u32_argb_premul); } } @@ -177,7 +163,8 @@ print_ascii_art(wuffs_base__pixel_buffer* pb) { for (y = 0; y < height; y++) { uint32_t x; for (x = 0; x < width; x++) { - wuffs_base__color_u32_argb_premul c = load_u32le(d); + wuffs_base__color_u32_argb_premul c = + wuffs_base__load_u32le__no_bounds_check(d); d += sizeof(wuffs_base__color_u32_argb_premul); // Convert to grayscale via the formula // Y = (0.299 * R) + (0.587 * G) + (0.114 * B) @@ -206,7 +193,8 @@ print_color_art(wuffs_base__pixel_buffer* pb) { for (y = 0; y < height; y++) { uint32_t x; for (x = 0; x < width; x++) { - wuffs_base__color_u32_argb_premul c = load_u32le(d); + wuffs_base__color_u32_argb_premul c = + wuffs_base__load_u32le__no_bounds_check(d); d += sizeof(wuffs_base__color_u32_argb_premul); int b = 0xFF & (c >> 0); int g = 0xFF & (c >> 8); @@ -354,7 +342,7 @@ play() { size_t n = dst_len / sizeof(wuffs_base__color_u32_argb_premul); uint8_t* p = curr_dst_buffer; for (i = 0; i < n; i++) { - store_u32le(p, background_color); + wuffs_base__store_u32le__no_bounds_check(p, background_color); p += sizeof(wuffs_base__color_u32_argb_premul); } } diff --git a/example/imageviewer/imageviewer.c b/example/imageviewer/imageviewer.c index f1634a0e..b7120530 100644 --- a/example/imageviewer/imageviewer.c +++ b/example/imageviewer/imageviewer.c @@ -96,14 +96,6 @@ union { wuffs_wbmp__decoder wbmp; } g_potential_decoders; -static inline void // -store_u32le(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); -} - bool // read_more_src() { if (g_src.meta.closed) { @@ -246,7 +238,7 @@ load_image_config() { wuffs_base__color_u32_argb_premul color = g_background_colors[g_background_color_index]; for (size_t i = 0; i < num_pixels; i++) { - store_u32le(ptr, color); + wuffs_base__store_u32le__no_bounds_check(ptr, color); ptr += 4; } } diff --git a/internal/cgen/base/core-private.h b/internal/cgen/base/core-private.h index e633a876..a9a786f7 100644 --- a/internal/cgen/base/core-private.h +++ b/internal/cgen/base/core-private.h @@ -73,252 +73,8 @@ wuffs_base__ignore_status(wuffs_base__status z) { #define WUFFS_BASE__UNLIKELY(expr) (expr) #endif -// The helpers below are functions, instead of macros, because their arguments -// can be an expression that we shouldn't evaluate more than once. -// -// They are static, so that linking multiple wuffs .o files won't complain about -// duplicate function definitions. -// -// They are explicitly marked inline, even if modern compilers don't use the -// inline attribute to guide optimizations such as inlining, to avoid the -// -Wunused-function warning, and we like to compile with -Wall -Werror. - // ---------------- Numeric Types -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) { - return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); -} - -static inline uint16_t // -wuffs_base__load_u16le(uint8_t* p) { - return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); -} - -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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) | ((uint64_t)(p[7]) << 56); -} - -// -------- - -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) { - p[0] = (uint8_t)(x >> 8); - p[1] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u16le(uint8_t* p, uint16_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); -} - -static inline void // -wuffs_base__store_u24be(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 16); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u24le(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); -} - -static inline void // -wuffs_base__store_u32be(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 24); - p[1] = (uint8_t)(x >> 16); - p[2] = (uint8_t)(x >> 8); - p[3] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u32le(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); -} - -static inline void // -wuffs_base__store_u40be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 32); - p[1] = (uint8_t)(x >> 24); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 8); - p[4] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u40le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); -} - -static inline void // -wuffs_base__store_u48be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 40); - p[1] = (uint8_t)(x >> 32); - p[2] = (uint8_t)(x >> 24); - p[3] = (uint8_t)(x >> 16); - p[4] = (uint8_t)(x >> 8); - p[5] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u48le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); - p[5] = (uint8_t)(x >> 40); -} - -static inline void // -wuffs_base__store_u56be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 48); - p[1] = (uint8_t)(x >> 40); - p[2] = (uint8_t)(x >> 32); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 16); - p[5] = (uint8_t)(x >> 8); - p[6] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u56le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); - p[5] = (uint8_t)(x >> 40); - p[6] = (uint8_t)(x >> 48); -} - -static inline void // -wuffs_base__store_u64be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 56); - p[1] = (uint8_t)(x >> 48); - p[2] = (uint8_t)(x >> 40); - p[3] = (uint8_t)(x >> 32); - p[4] = (uint8_t)(x >> 24); - p[5] = (uint8_t)(x >> 16); - p[6] = (uint8_t)(x >> 8); - p[7] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u64le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); - p[5] = (uint8_t)(x >> 40); - p[6] = (uint8_t)(x >> 48); - p[7] = (uint8_t)(x >> 56); -} - -// -------- - extern const uint8_t wuffs_base__low_bits_mask__u8[9]; extern const uint16_t wuffs_base__low_bits_mask__u16[17]; extern const uint32_t wuffs_base__low_bits_mask__u32[33]; diff --git a/internal/cgen/base/core-public.h b/internal/cgen/base/core-public.h index 74401ac8..5277eef6 100644 --- a/internal/cgen/base/core-public.h +++ b/internal/cgen/base/core-public.h @@ -268,6 +268,16 @@ typedef int64_t wuffs_base__flicks; // ---------------- Numeric Types +// The helpers below are functions, instead of macros, because their arguments +// can be an expression that we shouldn't evaluate more than once. +// +// They are static, so that linking multiple wuffs .o files won't complain about +// duplicate function definitions. +// +// They are explicitly marked inline, even if modern compilers don't use the +// inline attribute to guide optimizations such as inlining, to avoid the +// -Wunused-function warning, and we like to compile with -Wall -Werror. + static inline uint8_t // wuffs_base__u8__min(uint8_t x, uint8_t y) { return x < y ? x : y; @@ -372,6 +382,250 @@ wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { return res; } + // -------- + +#define wuffs_base__load_u8be__no_bounds_check \ + wuffs_base__load_u8__no_bounds_check +#define wuffs_base__load_u8le__no_bounds_check \ + wuffs_base__load_u8__no_bounds_check + +static inline uint8_t // +wuffs_base__load_u8__no_bounds_check(uint8_t* p) { + return p[0]; +} + +static inline uint16_t // +wuffs_base__load_u16be__no_bounds_check(uint8_t* p) { + return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); +} + +static inline uint16_t // +wuffs_base__load_u16le__no_bounds_check(uint8_t* p) { + return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); +} + +static inline uint32_t // +wuffs_base__load_u24be__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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) | ((uint64_t)(p[7]) << 56); +} + + // -------- + +#define wuffs_base__store_u8be__no_bounds_check \ + wuffs_base__store_u8__no_bounds_check +#define wuffs_base__store_u8le__no_bounds_check \ + wuffs_base__store_u8__no_bounds_check + +static inline void // +wuffs_base__store_u8__no_bounds_check(uint8_t* p, uint8_t x) { + p[0] = x; +} + +static inline void // +wuffs_base__store_u16be__no_bounds_check(uint8_t* p, uint16_t x) { + p[0] = (uint8_t)(x >> 8); + p[1] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u16le__no_bounds_check(uint8_t* p, uint16_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); +} + +static inline void // +wuffs_base__store_u24be__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 16); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u24le__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); +} + +static inline void // +wuffs_base__store_u32be__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 24); + p[1] = (uint8_t)(x >> 16); + p[2] = (uint8_t)(x >> 8); + p[3] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u32le__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); +} + +static inline void // +wuffs_base__store_u40be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 32); + p[1] = (uint8_t)(x >> 24); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 8); + p[4] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u40le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); +} + +static inline void // +wuffs_base__store_u48be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 40); + p[1] = (uint8_t)(x >> 32); + p[2] = (uint8_t)(x >> 24); + p[3] = (uint8_t)(x >> 16); + p[4] = (uint8_t)(x >> 8); + p[5] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u48le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); + p[5] = (uint8_t)(x >> 40); +} + +static inline void // +wuffs_base__store_u56be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 48); + p[1] = (uint8_t)(x >> 40); + p[2] = (uint8_t)(x >> 32); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 16); + p[5] = (uint8_t)(x >> 8); + p[6] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u56le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); + p[5] = (uint8_t)(x >> 40); + p[6] = (uint8_t)(x >> 48); +} + +static inline void // +wuffs_base__store_u64be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 56); + p[1] = (uint8_t)(x >> 48); + p[2] = (uint8_t)(x >> 40); + p[3] = (uint8_t)(x >> 32); + p[4] = (uint8_t)(x >> 24); + p[5] = (uint8_t)(x >> 16); + p[6] = (uint8_t)(x >> 8); + p[7] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u64le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); + p[5] = (uint8_t)(x >> 40); + p[6] = (uint8_t)(x >> 48); + p[7] = (uint8_t)(x >> 56); +} + // ---------------- Slices and Tables // WUFFS_BASE__SLICE is a 1-dimensional buffer. diff --git a/internal/cgen/base/image-impl.c b/internal/cgen/base/image-impl.c index 2dd03397..e4ddec54 100644 --- a/internal/cgen/base/image-impl.c +++ b/internal/cgen/base/image-impl.c @@ -124,13 +124,14 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* b, case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: - return wuffs_base__load_u32le(row + (4 * ((size_t)x))); + return wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: { uint8_t* palette = b->private_impl.planes[3].ptr; - return wuffs_base__load_u32le(palette + (4 * ((size_t)row[x]))); + return wuffs_base__load_u32le__no_bounds_check(palette + + (4 * ((size_t)row[x]))); } // Common formats above. Rarer formats below. @@ -141,11 +142,13 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* b, case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: { uint8_t* palette = b->private_impl.planes[3].ptr; return wuffs_base__premul_u32_axxx( - wuffs_base__load_u32le(palette + (4 * ((size_t)row[x])))); + wuffs_base__load_u32le__no_bounds_check(palette + + (4 * ((size_t)row[x])))); } case WUFFS_BASE__PIXEL_FORMAT__BGR_565: { - uint16_t bgr = wuffs_base__load_u16le(row + (2 * ((size_t)x))); + uint16_t bgr = + wuffs_base__load_u16le__no_bounds_check(row + (2 * ((size_t)x))); uint32_t b5 = 0x1F & (bgr >> 0); uint32_t b = (b5 << 3) | (b5 >> 2); uint32_t g6 = 0x3F & (bgr >> 5); @@ -155,27 +158,31 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* b, return 0xFF000000 | (r << 16) | (g << 8) | (b << 0); } case WUFFS_BASE__PIXEL_FORMAT__BGR: - return 0xFF000000 | wuffs_base__load_u24le(row + (3 * ((size_t)x))); + return 0xFF000000 | + wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__BGRX: - return 0xFF000000 | wuffs_base__load_u32le(row + (4 * ((size_t)x))); + return 0xFF000000 | + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: return wuffs_base__premul_u32_axxx( - wuffs_base__load_u32le(row + (4 * ((size_t)x)))); + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))); case WUFFS_BASE__PIXEL_FORMAT__RGB: return wuffs_base__swap_u32_argb_abgr( - 0xFF000000 | wuffs_base__load_u24le(row + (3 * ((size_t)x)))); + 0xFF000000 | + wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x)))); case WUFFS_BASE__PIXEL_FORMAT__RGBX: return wuffs_base__swap_u32_argb_abgr( - 0xFF000000 | wuffs_base__load_u32le(row + (4 * ((size_t)x)))); + 0xFF000000 | + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))); case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: return wuffs_base__swap_u32_argb_abgr(wuffs_base__premul_u32_axxx( - wuffs_base__load_u32le(row + (4 * ((size_t)x))))); + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))))); case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: return wuffs_base__swap_u32_argb_abgr( - wuffs_base__load_u32le(row + (4 * ((size_t)x)))); + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))); default: // TODO: support more formats. @@ -211,7 +218,7 @@ wuffs_base__pixel_buffer__set_color_u32_at( case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__BGRX: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), color); + wuffs_base__store_u32le__no_bounds_check(row + (4 * ((size_t)x)), color); break; // Common formats above. Rarer formats below. @@ -221,31 +228,32 @@ wuffs_base__pixel_buffer__set_color_u32_at( uint32_t g6 = 0x3F & (color >> (16 - 6)); uint32_t r5 = 0x1F & (color >> (24 - 5)); uint32_t bgr565 = (b5 << 0) | (g6 << 5) | (r5 << 11); - wuffs_base__store_u16le(row + (2 * ((size_t)x)), (uint16_t)bgr565); + wuffs_base__store_u16le__no_bounds_check(row + (2 * ((size_t)x)), + (uint16_t)bgr565); break; } case WUFFS_BASE__PIXEL_FORMAT__BGR: - wuffs_base__store_u24le(row + (3 * ((size_t)x)), color); + wuffs_base__store_u24le__no_bounds_check(row + (3 * ((size_t)x)), color); break; case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), - wuffs_base__nonpremul_u32_axxx(color)); + wuffs_base__store_u32le__no_bounds_check( + row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx(color)); break; case WUFFS_BASE__PIXEL_FORMAT__RGB: - wuffs_base__store_u24le(row + (3 * ((size_t)x)), - wuffs_base__swap_u32_argb_abgr(color)); + wuffs_base__store_u24le__no_bounds_check( + row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color)); break; case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), - wuffs_base__nonpremul_u32_axxx( - wuffs_base__swap_u32_argb_abgr(color))); + wuffs_base__store_u32le__no_bounds_check( + row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx( + wuffs_base__swap_u32_argb_abgr(color))); break; case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__RGBX: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), - wuffs_base__swap_u32_argb_abgr(color)); + wuffs_base__store_u32le__no_bounds_check( + row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color)); break; default: @@ -273,9 +281,9 @@ wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src( // TODO: unroll. while (n >= 1) { - uint32_t s0 = - wuffs_base__premul_u32_axxx(wuffs_base__load_u32le(s + (0 * 4))); - wuffs_base__store_u32le(d + (0 * 4), s0); + uint32_t s0 = wuffs_base__premul_u32_axxx( + wuffs_base__load_u32le__no_bounds_check(s + (0 * 4))); + wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0); s += 1 * 4; d += 1 * 4; @@ -300,9 +308,9 @@ wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over( // TODO: unroll. while (n >= 1) { - uint32_t d0 = wuffs_base__load_u32le(d + (0 * 4)); - uint32_t s0 = wuffs_base__load_u32le(s + (0 * 4)); - wuffs_base__store_u32le( + uint32_t d0 = wuffs_base__load_u32le__no_bounds_check(d + (0 * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(s + (0 * 4)); + wuffs_base__store_u32le__no_bounds_check( d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0)); s += 1 * 4; @@ -349,18 +357,18 @@ wuffs_base__pixel_swizzler__xx__index__src(wuffs_base__slice_u8 dst, const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - wuffs_base__store_u16le( - d + (0 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[0] * 4))); - wuffs_base__store_u16le( - d + (1 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[1] * 4))); - wuffs_base__store_u16le( - d + (2 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[2] * 4))); - wuffs_base__store_u16le( - d + (3 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[3] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (0 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (1 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[1] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (2 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[2] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (3 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[3] * 4))); s += loop_unroll_count * 1; d += loop_unroll_count * 2; @@ -368,9 +376,9 @@ wuffs_base__pixel_swizzler__xx__index__src(wuffs_base__slice_u8 dst, } while (n >= 1) { - wuffs_base__store_u16le( - d + (0 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (0 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); s += 1 * 1; d += 1 * 2; @@ -402,18 +410,18 @@ wuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst, // overwrite that with the correct byte. There is always another store, // whether a 4-byte store in this loop or a 1-byte store in the next loop. while (n > loop_unroll_count) { - wuffs_base__store_u32le( - d + (0 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4))); - wuffs_base__store_u32le( - d + (1 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4))); - wuffs_base__store_u32le( - d + (2 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4))); - wuffs_base__store_u32le( - d + (3 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (1 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[1] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (2 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[2] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (3 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[3] * 4))); s += loop_unroll_count * 1; d += loop_unroll_count * 3; @@ -421,7 +429,8 @@ wuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst, } while (n >= 1) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); d[0] = (uint8_t)(s0 >> 0); d[1] = (uint8_t)(s0 >> 8); d[2] = (uint8_t)(s0 >> 16); @@ -451,21 +460,25 @@ wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over( const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u24le(d + (0 * 4), s0); + wuffs_base__store_u24le__no_bounds_check(d + (0 * 4), s0); } - uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)); + uint32_t s1 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[1] * 4)); if (s1) { - wuffs_base__store_u24le(d + (1 * 4), s1); + wuffs_base__store_u24le__no_bounds_check(d + (1 * 4), s1); } - uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)); + uint32_t s2 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[2] * 4)); if (s2) { - wuffs_base__store_u24le(d + (2 * 4), s2); + wuffs_base__store_u24le__no_bounds_check(d + (2 * 4), s2); } - uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)); + uint32_t s3 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[3] * 4)); if (s3) { - wuffs_base__store_u24le(d + (3 * 4), s3); + wuffs_base__store_u24le__no_bounds_check(d + (3 * 4), s3); } s += loop_unroll_count * 1; @@ -474,9 +487,10 @@ wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over( } while (n >= 1) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u24le(d + (0 * 4), s0); + wuffs_base__store_u24le__no_bounds_check(d + (0 * 4), s0); } s += 1 * 1; @@ -503,18 +517,18 @@ wuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst, const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - wuffs_base__store_u32le( - d + (0 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4))); - wuffs_base__store_u32le( - d + (1 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4))); - wuffs_base__store_u32le( - d + (2 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4))); - wuffs_base__store_u32le( - d + (3 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (1 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[1] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (2 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[2] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (3 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[3] * 4))); s += loop_unroll_count * 1; d += loop_unroll_count * 4; @@ -522,9 +536,9 @@ wuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst, } while (n >= 1) { - wuffs_base__store_u32le( - d + (0 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); s += 1 * 1; d += 1 * 4; @@ -551,21 +565,25 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u32le(d + (0 * 4), s0); + wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0); } - uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)); + uint32_t s1 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[1] * 4)); if (s1) { - wuffs_base__store_u32le(d + (1 * 4), s1); + wuffs_base__store_u32le__no_bounds_check(d + (1 * 4), s1); } - uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)); + uint32_t s2 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[2] * 4)); if (s2) { - wuffs_base__store_u32le(d + (2 * 4), s2); + wuffs_base__store_u32le__no_bounds_check(d + (2 * 4), s2); } - uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)); + uint32_t s3 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[3] * 4)); if (s3) { - wuffs_base__store_u32le(d + (3 * 4), s3); + wuffs_base__store_u32le__no_bounds_check(d + (3 * 4), s3); } s += loop_unroll_count * 1; @@ -574,9 +592,10 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( } while (n >= 1) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u32le(d + (0 * 4), s0); + wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0); } s += 1 * 1; @@ -601,8 +620,9 @@ wuffs_base__pixel_swizzler__xxxx__xxx(wuffs_base__slice_u8 dst, // TODO: unroll. while (n >= 1) { - wuffs_base__store_u32le(d + (0 * 4), - 0xFF000000 | wuffs_base__load_u24le(s + (0 * 3))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), + 0xFF000000 | wuffs_base__load_u24le__no_bounds_check(s + (0 * 3))); s += 1 * 3; d += 1 * 4; @@ -625,8 +645,8 @@ wuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst, // TODO: unroll. while (n >= 1) { - wuffs_base__store_u32le(d + (0 * 4), - 0xFF000000 | (0x010101 * (uint32_t)s[0])); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); s += 1 * 1; d += 1 * 4; @@ -647,11 +667,12 @@ wuffs_base__pixel_swizzler__squash_bgr_565_888(wuffs_base__slice_u8 dst, size_t n = len4; while (n--) { - uint32_t argb = wuffs_base__load_u32le(s); + uint32_t argb = wuffs_base__load_u32le__no_bounds_check(s); uint32_t b5 = 0x1F & (argb >> (8 - 5)); uint32_t g6 = 0x3F & (argb >> (16 - 6)); uint32_t r5 = 0x1F & (argb >> (24 - 5)); - wuffs_base__store_u32le(d, (b5 << 0) | (g6 << 5) | (r5 << 11)); + wuffs_base__store_u32le__no_bounds_check( + d, (b5 << 0) | (g6 << 5) | (r5 << 11)); s += 4; d += 4; } diff --git a/internal/cgen/base/io-private.h b/internal/cgen/base/io-private.h index b4e43c9a..db61e880 100644 --- a/internal/cgen/base/io-private.h +++ b/internal/cgen/base/io-private.h @@ -183,7 +183,7 @@ wuffs_base__io_reader__match7(uint8_t* iop_r, uint32_t n = a & 7; a >>= 8; if ((io2_r - iop_r) >= 8) { - uint64_t x = wuffs_base__load_u64le(iop_r); + uint64_t x = wuffs_base__load_u64le__no_bounds_check(iop_r); uint32_t shift = 8 * (8 - n); return ((a << shift) == (x << shift)) ? 0 : 2; } @@ -251,7 +251,7 @@ wuffs_base__io_writer__set(wuffs_base__io_buffer* b, return b; } -// ---------------- I/O (Utility) + // ---------------- I/O (Utility) #define wuffs_base__utility__empty_io_reader wuffs_base__empty_io_reader #define wuffs_base__utility__empty_io_writer wuffs_base__empty_io_writer diff --git a/internal/cgen/builtin.go b/internal/cgen/builtin.go index 33ba1320..55562a4c 100644 --- a/internal/cgen/builtin.go +++ b/internal/cgen/builtin.go @@ -214,7 +214,7 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args [] if p.size != p.n { b.printf("((uint%d_t)(", p.size) } - b.printf("wuffs_base__load_u%d%ce(%s%s)", p.n, p.endianness, iopPrefix, name) + b.printf("wuffs_base__load_u%d%ce__no_bounds_check(%s%s)", p.n, p.endianness, iopPrefix, name) if p.size != p.n { b.writes("))") } @@ -308,7 +308,7 @@ func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args [] // final part is a function call (to a static inline function) // instead of a struct literal, to avoid a "expression result // unused" compiler error. - b.printf("(wuffs_base__store_u%d%ce(%s%s,", p.n, p.endianness, iopPrefix, name) + b.printf("(wuffs_base__store_u%d%ce__no_bounds_check(%s%s,", p.n, p.endianness, iopPrefix, name) if err := g.writeExpr(b, args[0].AsArg().Value(), depth); err != nil { return err } @@ -746,7 +746,7 @@ func (g *gen) writeReadUxxAsUyy(b *buffer, n *a.Expr, preName string, xx uint8, if xx != yy { b.printf("((uint%d_t)(", yy) } - b.printf("wuffs_base__load_u%d%ce(iop_a_src)", xx, endianness) + b.printf("wuffs_base__load_u%d%ce__no_bounds_check(iop_a_src)", xx, endianness) if xx != yy { b.writes("))") } diff --git a/internal/cgen/data.go b/internal/cgen/data.go index d2406ffd..885cfe04 100644 --- a/internal/cgen/data.go +++ b/internal/cgen/data.go @@ -30,27 +30,28 @@ const baseImageImplC = "" + "// ---------------- Images\n\nconst uint32_t wuffs_base__pixel_format__bits_per_channel[16] = {\n 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n 0x08, 0x0A, 0x0C, 0x10, 0x18, 0x20, 0x30, 0x40,\n};\n\nstatic inline uint32_t //\nwuffs_base__swap_u32_argb_abgr(uint32_t u) {\n uint32_t o = u & 0xFF00FF00;\n uint32_t r = u & 0x00FF0000;\n uint32_t b = u & 0x000000FF;\n return o | (r >> 16) | (b << 16);\n}\n\nstatic inline uint32_t //\nwuffs_base__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,\n uint32_t src_nonpremul) {\n // Convert from 8-bit color to 16-bit color.\n uint32_t sa = 0x101 * (0xFF & (src_nonpremul >> 24));\n uint32_t sr = 0x101 * (0xFF & (src_nonpremul >> 16));\n uint32_t sg = 0x101 * (0xFF & (src_nonpremul >> 8));\n uint32_t sb = 0x101 * (0xFF & (src_nonpremul >> 0));\n uint32_t da = 0x101 * (0xFF & (dst_premul >> 24));\n uint32_t dr = 0x101 * (0xFF & (dst_premul >> 16));\n uint32_t dg = 0x101 * (0xFF & (dst_premul >> 8));\n uint32_t db = 0x101" + " * (0xFF & (dst_premul >> 0));\n\n // Calculate the inverse of the src-alpha: how much of the dst to keep.\n uint32_t ia = 0xFFFF - sa;\n\n // Composite src (nonpremul) over dst (premul).\n da = sa + ((da * ia) / 0xFFFF);\n dr = ((sr * sa) + (dr * ia)) / 0xFFFF;\n dg = ((sg * sa) + (dg * ia)) / 0xFFFF;\n db = ((sb * sa) + (db * ia)) / 0xFFFF;\n\n // Convert from 16-bit color to 8-bit color and combine the components.\n da >>= 8;\n dr >>= 8;\n dg >>= 8;\n db >>= 8;\n return (db << 0) | (dg << 8) | (dr << 16) | (da << 24);\n}\n\nstatic inline uint32_t //\nwuffs_base__premul_u32_axxx(uint32_t nonpremul) {\n // Multiplying by 0x101 (twice, once for alpha and once for color) converts\n // from 8-bit to 16-bit color. Shifting right by 8 undoes that.\n //\n // Working in the higher bit depth can produce slightly different (and\n // arguably slightly more accurate) results. For example, given 8-bit blue\n // and alpha of 0x80 and 0x81:\n //\n // - ((0x80 * 0x81 ) / 0xFF ) = 0x40 = 0x40\n // - ((0x8080 * 0" + "x8181) / 0xFFFF) >> 8 = 0x4101 >> 8 = 0x41\n uint32_t a = 0xFF & (nonpremul >> 24);\n uint32_t a16 = a * (0x101 * 0x101);\n\n uint32_t r = 0xFF & (nonpremul >> 16);\n r = ((r * a16) / 0xFFFF) >> 8;\n uint32_t g = 0xFF & (nonpremul >> 8);\n g = ((g * a16) / 0xFFFF) >> 8;\n uint32_t b = 0xFF & (nonpremul >> 0);\n b = ((b * a16) / 0xFFFF) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\nstatic inline uint32_t //\nwuffs_base__nonpremul_u32_axxx(uint32_t premul) {\n uint32_t a = 0xFF & (premul >> 24);\n if (a == 0xFF) {\n return premul;\n } else if (a == 0) {\n return 0;\n }\n uint32_t a16 = a * 0x101;\n\n uint32_t r = 0xFF & (premul >> 16);\n r = ((r * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t g = 0xFF & (premul >> 8);\n g = ((g * (0x101 * 0xFFFF)) / a16) >> 8;\n uint32_t b = 0xFF & (premul >> 0);\n b = ((b * (0x101 * 0xFFFF)) / a16) >> 8;\n\n return (a << 24) | (r << 16) | (g << 8) | (b << 0);\n}\n\nwuffs_base__color_u32_argb_premul //\nwuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_" + - "buffer* b,\n uint32_t x,\n uint32_t y) {\n if (!b || (x >= b->pixcfg.private_impl.width) ||\n (y >= b->pixcfg.private_impl.height)) {\n return 0;\n }\n\n if (wuffs_base__pixel_format__is_planar(&b->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return 0;\n }\n\n size_t stride = b->private_impl.planes[0].stride;\n uint8_t* row = b->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (b->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__load_u32le(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {\n uint8_t* palette = b->private_impl.planes[3].ptr;\n return wuffs_base__load_u32le(palette + (4 * ((size_t)row[x])));\n }\n\n // Common" + - " formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[x])));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {\n uint8_t* palette = b->private_impl.planes[3].ptr;\n return wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le(palette + (4 * ((size_t)row[x]))));\n }\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {\n uint16_t bgr = wuffs_base__load_u16le(row + (2 * ((size_t)x)));\n uint32_t b5 = 0x1F & (bgr >> 0);\n uint32_t b = (b5 << 3) | (b5 >> 2);\n uint32_t g6 = 0x3F & (bgr >> 5);\n uint32_t g = (g6 << 2) | (g6 >> 4);\n uint32_t r5 = 0x1F & (bgr >> 11);\n uint32_t r = (r5 << 3) | (r5 >> 2);\n return 0xFF000000 | (r << 16) | (g << 8) | (b << 0);\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n return 0xFF000000 | wuffs_base__load_u24le(row + (3 * ((size_t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return 0xFF000000 | wuffs_base__load_u32le(row + (4 * ((size_" + - "t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n return wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le(row + (4 * ((size_t)x))));\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 | wuffs_base__load_u24le(row + (3 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 | wuffs_base__load_u32le(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n return wuffs_base__swap_u32_argb_abgr(wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le(row + (4 * ((size_t)x)))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n return wuffs_base__swap_u32_argb_abgr(\n wuffs_base__load_u32le(row + (4 * ((size_t)x))));\n\n default:\n // TODO: support more formats.\n break;\n }\n\n return 0;\n}\n\nwuffs_base__status //\nwuffs_base__pixel_buf" + - "fer__set_color_u32_at(\n wuffs_base__pixel_buffer* b,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color) {\n if (!b) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n if ((x >= b->pixcfg.private_impl.width) ||\n (y >= b->pixcfg.private_impl.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&b->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n size_t stride = b->private_impl.planes[0].stride;\n uint8_t* row = b->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (b->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__store_u32le(row + (4 * ((size_t)x)), color);\n break;\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__" + - "PIXEL_FORMAT__BGR_565: {\n uint32_t b5 = 0x1F & (color >> (8 - 5));\n uint32_t g6 = 0x3F & (color >> (16 - 6));\n uint32_t r5 = 0x1F & (color >> (24 - 5));\n uint32_t bgr565 = (b5 << 0) | (g6 << 5) | (r5 << 11);\n wuffs_base__store_u16le(row + (2 * ((size_t)x)), (uint16_t)bgr565);\n break;\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__store_u24le(row + (3 * ((size_t)x)), color);\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__store_u32le(row + (4 * ((size_t)x)),\n wuffs_base__nonpremul_u32_axxx(color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n wuffs_base__store_u24le(row + (3 * ((size_t)x)),\n wuffs_base__swap_u32_argb_abgr(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__store_u32le(row + (4 * ((size_t)x)),\n wuffs_base__nonpremul_u32_axxx(\n wuffs_base__swap_" + - "u32_argb_abgr(color)));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__store_u32le(row + (4 * ((size_t)x)),\n wuffs_base__swap_u32_argb_abgr(color));\n break;\n\n default:\n // TODO: support more formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n return wuffs_base__make_status(NULL);\n}\n\n" + + "buffer* b,\n uint32_t x,\n uint32_t y) {\n if (!b || (x >= b->pixcfg.private_impl.width) ||\n (y >= b->pixcfg.private_impl.height)) {\n return 0;\n }\n\n if (wuffs_base__pixel_format__is_planar(&b->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return 0;\n }\n\n size_t stride = b->private_impl.planes[0].stride;\n uint8_t* row = b->private_impl.planes[0].ptr + (stride * ((size_t)y));\n\n switch (b->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n return wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {\n uint8_t* palette = b->private_impl.planes[3].ptr;\n return wuffs_base__load_u32le__no_bounds_check(palette +\n " + + " (4 * ((size_t)row[x])));\n }\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__Y:\n return 0xFF000000 | (0x00010101 * ((uint32_t)(row[x])));\n\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {\n uint8_t* palette = b->private_impl.planes[3].ptr;\n return wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(palette +\n (4 * ((size_t)row[x]))));\n }\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {\n uint16_t bgr =\n wuffs_base__load_u16le__no_bounds_check(row + (2 * ((size_t)x)));\n uint32_t b5 = 0x1F & (bgr >> 0);\n uint32_t b = (b5 << 3) | (b5 >> 2);\n uint32_t g6 = 0x3F & (bgr >> 5);\n uint32_t g = (g6 << 2) | (g6 >> 4);\n uint32_t r5 = 0x1F & (bgr >> 11);\n uint32_t r = (r5 << 3) | (r5 >> 2);\n return 0xFF000000 | (r << 16) | (g << 8) | (b << 0);\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n " + + " return 0xFF000000 |\n wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n return 0xFF000000 |\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)));\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n return wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n return wuffs_base__swap_u32_argb_abgr(\n 0xFF000000 |\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n return wuffs_base__swap_u32_argb_abgr(wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))));\n case WUFFS_BASE__PIXEL_FORM" + + "AT__RGBA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n return wuffs_base__swap_u32_argb_abgr(\n wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))));\n\n default:\n // TODO: support more formats.\n break;\n }\n\n return 0;\n}\n\nwuffs_base__status //\nwuffs_base__pixel_buffer__set_color_u32_at(\n wuffs_base__pixel_buffer* b,\n uint32_t x,\n uint32_t y,\n wuffs_base__color_u32_argb_premul color) {\n if (!b) {\n return wuffs_base__make_status(wuffs_base__error__bad_receiver);\n }\n if ((x >= b->pixcfg.private_impl.width) ||\n (y >= b->pixcfg.private_impl.height)) {\n return wuffs_base__make_status(wuffs_base__error__bad_argument);\n }\n\n if (wuffs_base__pixel_format__is_planar(&b->pixcfg.private_impl.pixfmt)) {\n // TODO: support planar formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n size_t stride = b->private_impl.planes[0].stride;\n uint8_t* row = b->private_impl.planes[0].ptr " + + "+ (stride * ((size_t)y));\n\n switch (b->pixcfg.private_impl.pixfmt.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n wuffs_base__store_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);\n break;\n\n // Common formats above. Rarer formats below.\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {\n uint32_t b5 = 0x1F & (color >> (8 - 5));\n uint32_t g6 = 0x3F & (color >> (16 - 6));\n uint32_t r5 = 0x1F & (color >> (24 - 5));\n uint32_t bgr565 = (b5 << 0) | (g6 << 5) | (r5 << 11);\n wuffs_base__store_u16le__no_bounds_check(row + (2 * ((size_t)x)),\n (uint16_t)bgr565);\n break;\n }\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n wuffs_base__store_u24le__no_bounds_check(row + (3 * ((size_t)x)), color);\n break;\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_bas" + + "e__nonpremul_u32_axxx(color));\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n wuffs_base__store_u24le__no_bounds_check(\n row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx(\n wuffs_base__swap_u32_argb_abgr(color)));\n break;\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n WUFFS_BASE__FALLTHROUGH;\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n wuffs_base__store_u32le__no_bounds_check(\n row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color));\n break;\n\n default:\n // TODO: support more formats.\n return wuffs_base__make_status(wuffs_base__error__unsupported_option);\n }\n\n return wuffs_base__make_status(NULL);\n}\n\n" + "" + - "// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 =\n wuffs_base__premul_u32_axxx(wuffs_base__load_u32le(s + (0 * 4)));\n wuffs_base__store_u32le(d + (0 * 4), s0);\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unrol" + - "l.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__load_u32le(d + (0 * 4));\n uint32_t s0 = wuffs_base__load_u32le(s + (0 * 4));\n wuffs_base__store_u32le(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n return wuffs_base__slice_u8__copy_from_slice(dst, src);\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_4_4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n if (len > 0) {\n memmove(dst.ptr, src.ptr, len * 4);\n }\n return len;\n}\n\nstatic uint64_t" + - " //\nwuffs_base__pixel_swizzler__xx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len2 = dst.len / 2;\n size_t len = dst_len2 < src.len ? dst_len2 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__store_u16le(\n d + (0 * 2),\n wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u16le(\n d + (1 * 2),\n wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u16le(\n d + (2 * 2),\n wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_base__store_u16le(\n d + (3 * 2),\n wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n " + - "d += loop_unroll_count * 2;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__store_u16le(\n d + (0 * 2),\n wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n // The comparison in the while condition is \">\", not \">=\", because with \">=\",\n // the last 4-byte store could write past the end of the dst slice.\n //\n // Each 4-byte store writes one too many bytes, but a subsequent store will\n // overwrite that with the correct " + - "byte. There is always another store,\n // whether a 4-byte store in this loop or a 1-byte store in the next loop.\n while (n > loop_unroll_count) {\n wuffs_base__store_u32le(\n d + (0 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u32le(\n d + (1 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u32le(\n d + (2 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_base__store_u32le(\n d + (3 * 3),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4));\n d[0] = (uint8_t)(s0 >> 0);\n d[1] = (uint8_t)(s0 >> 8);\n d[2] = (uint8_t)(s0 >> 16);\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pi" + - "xel_swizzler__xxx__index_binary_alpha__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u24le(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__store_u24le(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__store_u24le(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__store_u24le(d + (3 * 4), s3);\n }\n\n " + - " s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u24le(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u32le(\n d + (1 * 4)," + - "\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u32le(\n d + (2 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_base__store_u32le(\n d + (3 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__store_u32le(\n d + (0 * 4),\n wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t" + - " loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u32le(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__store_u32le(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__store_u32le(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__store_u32le(d + (3 * 4), s3);\n }\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u32le(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_sw" + - "izzler__xxxx__xxx(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len3 = src.len / 3;\n size_t len = dst_len4 < src_len3 ? dst_len4 : src_len3;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__store_u32le(d + (0 * 4),\n 0xFF000000 | wuffs_base__load_u24le(s + (0 * 3)));\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base" + - "__store_u32le(d + (0 * 4),\n 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" + + "// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__premul_u32_axxx(\n wuffs_base__load_u32le__no_bounds_check(s + (0 * 4)));\n wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0);\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n" + + " size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n uint32_t d0 = wuffs_base__load_u32le__no_bounds_check(d + (0 * 4));\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(s + (0 * 4));\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0));\n\n s += 1 * 4;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_1_1(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n return wuffs_base__slice_u8__copy_from_slice(dst, src);\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__copy_4_4(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len4 = src.len / 4;\n size_t len = dst_len4 < src_len4 ? dst_len4 : src_len4;\n if (l" + + "en > 0) {\n memmove(dst.ptr, src.ptr, len * 4);\n }\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len2 = dst.len / 2;\n size_t len = dst_len2 < src.len ? dst_len2 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__store_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__load_u16le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u16le__no_bounds_check(\n d + (1 * 2), wuffs_base__load_u16le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u16le__no_bounds_check(\n d + (2 * 2), wuffs_base__load_u16le" + + "__no_bounds_check(\n dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_base__store_u16le__no_bounds_check(\n d + (3 * 2), wuffs_base__load_u16le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 2;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__store_u16le__no_bounds_check(\n d + (0 * 2), wuffs_base__load_u16le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 2;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint" + + "8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n // The comparison in the while condition is \">\", not \">=\", because with \">=\",\n // the last 4-byte store could write past the end of the dst slice.\n //\n // Each 4-byte store writes one too many bytes, but a subsequent store will\n // overwrite that with the correct byte. There is always another store,\n // whether a 4-byte store in this loop or a 1-byte store in the next loop.\n while (n > loop_unroll_count) {\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 3), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u32le__no_bounds_check(\n d + (1 * 3), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u32le__no_bounds_check(\n d + (2 * 3), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_b" + + "ase__store_u32le__no_bounds_check(\n d + (3 * 3), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[0] * 4));\n d[0] = (uint8_t)(s0 >> 0);\n d[1] = (uint8_t)(s0 >> 8);\n d[2] = (uint8_t)(s0 >> 16);\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len3 = dst.len / 3;\n size_t len = dst_len3 < src.len ? dst_len3 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n" + + " while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u24le__no_bounds_check(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__store_u24le__no_bounds_check(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[2] * 4));\n if (s2) {\n wuffs_base__store_u24le__no_bounds_check(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__store_u24le__no_bounds_check(d + (3 * 4), s3);\n }\n\n s += loop_unroll_count *" + + " 1;\n d += loop_unroll_count * 3;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u24le__no_bounds_check(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 1 * 3;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__load_u32le__no_bounds_chec" + + "k(\n dst_palette.ptr + ((size_t)s[0] * 4)));\n wuffs_base__store_u32le__no_bounds_check(\n d + (1 * 4), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[1] * 4)));\n wuffs_base__store_u32le__no_bounds_check(\n d + (2 * 4), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[2] * 4)));\n wuffs_base__store_u32le__no_bounds_check(\n d + (3 * 4), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[3] * 4)));\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 4), wuffs_base__load_u32le__no_bounds_check(\n dst_palette.ptr + ((size_t)s[0] * 4)));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_ov" + + "er(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n if (dst_palette.len != 1024) {\n return 0;\n }\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n const size_t loop_unroll_count = 4;\n\n while (n >= loop_unroll_count) {\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0);\n }\n uint32_t s1 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[1] * 4));\n if (s1) {\n wuffs_base__store_u32le__no_bounds_check(d + (1 * 4), s1);\n }\n uint32_t s2 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[2] * 4));\n " + + "if (s2) {\n wuffs_base__store_u32le__no_bounds_check(d + (2 * 4), s2);\n }\n uint32_t s3 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[3] * 4));\n if (s3) {\n wuffs_base__store_u32le__no_bounds_check(d + (3 * 4), s3);\n }\n\n s += loop_unroll_count * 1;\n d += loop_unroll_count * 4;\n n -= loop_unroll_count;\n }\n\n while (n >= 1) {\n uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr +\n ((size_t)s[0] * 4));\n if (s0) {\n wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0);\n }\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__xxx(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t src_len3 = src." + + "len / 3;\n size_t len = dst_len4 < src_len3 ? dst_len4 : src_len3;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 4),\n 0xFF000000 | wuffs_base__load_u24le__no_bounds_check(s + (0 * 3)));\n\n s += 1 * 3;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src) {\n size_t dst_len4 = dst.len / 4;\n size_t len = dst_len4 < src.len ? dst_len4 : src.len;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n size_t n = len;\n\n // TODO: unroll.\n\n while (n >= 1) {\n wuffs_base__store_u32le__no_bounds_check(\n d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0]));\n\n s += 1 * 1;\n d += 1 * 4;\n n -= 1;\n }\n\n return len;\n}\n\n" + "" + - "// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__squash_bgr_565_888(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t len4 = (dst.len < src.len ? dst.len : src.len) / 4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n\n size_t n = len4;\n while (n--) {\n uint32_t argb = wuffs_base__load_u32le(s);\n uint32_t b5 = 0x1F & (argb >> (8 - 5));\n uint32_t g6 = 0x3F & (argb >> (16 - 6));\n uint32_t r5 = 0x1F & (argb >> (24 - 5));\n wuffs_base__store_u32le(d, (b5 << 0) | (g6 << 5) | (r5 << 11));\n s += 4;\n d += 4;\n }\n return len4 * 4;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t len4 = (dst.len < src.len ? dst.len : src.len) / 4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n\n size_t n = len4;\n while (n--) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n uint8_t b2 = s[2];\n uint8_t b3 = s[3];\n " + - " d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = b3;\n s += 4;\n d += 4;\n }\n return len4 * 4;\n}\n\n" + + "// --------\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__squash_bgr_565_888(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t len4 = (dst.len < src.len ? dst.len : src.len) / 4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n\n size_t n = len4;\n while (n--) {\n uint32_t argb = wuffs_base__load_u32le__no_bounds_check(s);\n uint32_t b5 = 0x1F & (argb >> (8 - 5));\n uint32_t g6 = 0x3F & (argb >> (16 - 6));\n uint32_t r5 = 0x1F & (argb >> (24 - 5));\n wuffs_base__store_u32le__no_bounds_check(\n d, (b5 << 0) | (g6 << 5) | (r5 << 11));\n s += 4;\n d += 4;\n }\n return len4 * 4;\n}\n\nstatic uint64_t //\nwuffs_base__pixel_swizzler__swap_rgbx_bgrx(wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t len4 = (dst.len < src.len ? dst.len : src.len) / 4;\n uint8_t* d = dst.ptr;\n uint8_t* s = src.ptr;\n\n size_t n = len4;\n while (n--) {\n uint8_t b0 = s[0];\n uint8_t b1 = s[1];\n u" + + "int8_t b2 = s[2];\n uint8_t b3 = s[3];\n d[0] = b2;\n d[1] = b1;\n d[2] = b0;\n d[3] = b3;\n s += 4;\n d += 4;\n }\n return len4 * 4;\n}\n\n" + "" + "// --------\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__y(wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR:\n case WUFFS_BASE__PIXEL_FORMAT__RGB:\n // TODO.\n break;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGRX:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:\n case WUFFS_BASE__PIXEL_FORMAT__RGBX:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY:\n return wuf" + "fs_base__pixel_swizzler__xxxx__y;\n }\n return NULL;\n}\n\nstatic wuffs_base__pixel_swizzler__func //\nwuffs_base__pixel_swizzler__prepare__indexed__bgra_binary(\n wuffs_base__pixel_swizzler* p,\n wuffs_base__pixel_format dst_format,\n wuffs_base__slice_u8 dst_palette,\n wuffs_base__slice_u8 src_palette,\n wuffs_base__pixel_blend blend) {\n switch (dst_format.repr) {\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:\n case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:\n if (wuffs_base__slice_u8__copy_from_slice(dst_palette, src_palette) !=\n 1024) {\n return NULL;\n }\n switch (blend) {\n case WUFFS_BASE__PIXEL_BLEND__SRC:\n return wuffs_base__pixel_swizzler__copy_1_1;\n }\n return NULL;\n\n case WUFFS_BASE__PIXEL_FORMAT__BGR_565:\n if (wuffs_base__pixel_swizzler__squash_bgr_565_888(dst_palette,\n src_palette) != 1024) {\n " + @@ -82,19 +83,9 @@ const baseStrConvImplC = "" + const baseCorePrivateH = "" + "static inline wuffs_base__empty_struct //\nwuffs_base__ignore_status(wuffs_base__status z) {\n return wuffs_base__make_empty_struct();\n}\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// WUFFS_BASE__DISABLED is a magic number to indicate that a non-recoverable\n// error was previously encountered.\n//\n// Its (non-zero) value is arbitrary, based on md5sum(\"disabled\").\n#define WUFFS_BASE__DISABLED ((uint32_t)0x075AE3D2)\n\n// Denote intentional fallthroughs for -Wimplicit-fallthrough.\n//\n// The order matters here. Clang also defines \"__GNUC__\".\n#if defined(__clang__) && defined(__cplusplus) && (__cplusplus >= 201103L)\n#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]]\n#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7)\n#define WUFFS_BAS" + "E__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__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \\\n if (!status.repr) { \\\n goto ok; \\\n } else if (*status.repr != '$') { \\\n goto exit; \\\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\n" + + " = 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" + "" + - "// ---------------- 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)(((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)(((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 ((uint32_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 uint64_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 //\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] = (uint8_t)(x >> 8);\n p[1] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u16le(uint8_t* p, uint16_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n}\n\nstatic inline void //\nwuffs_base__store_u24be(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 16);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u24le(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n}\n\nstatic inline void //\nwuffs_base__store_u32be(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 24);\n p[1] = (uint8_t)(x >> 16);\n p[2] = (uint8_t)(x >> 8);\n p[3] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u32le(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x" + - " >> 16);\n p[3] = (uint8_t)(x >> 24);\n}\n\nstatic inline void //\nwuffs_base__store_u40be(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 32);\n p[1] = (uint8_t)(x >> 24);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 8);\n p[4] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u40le(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n}\n\nstatic inline void //\nwuffs_base__store_u48be(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 40);\n p[1] = (uint8_t)(x >> 32);\n p[2] = (uint8_t)(x >> 24);\n p[3] = (uint8_t)(x >> 16);\n p[4] = (uint8_t)(x >> 8);\n p[5] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u48le(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n}\n\nstatic inline void //\nwuffs_base__store_u56be(ui" + - "nt8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 48);\n p[1] = (uint8_t)(x >> 40);\n p[2] = (uint8_t)(x >> 32);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 16);\n p[5] = (uint8_t)(x >> 8);\n p[6] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u56le(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n}\n\nstatic inline void //\nwuffs_base__store_u64be(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 56);\n p[1] = (uint8_t)(x >> 48);\n p[2] = (uint8_t)(x >> 40);\n p[3] = (uint8_t)(x >> 32);\n p[4] = (uint8_t)(x >> 24);\n p[5] = (uint8_t)(x >> 16);\n p[6] = (uint8_t)(x >> 8);\n p[7] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u64le(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32" + - ");\n p[5] = (uint8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n p[7] = (uint8_t)(x >> 56);\n}\n\n" + - "" + - "// --------\n\nextern const uint8_t wuffs_base__low_bits_mask__u8[9];\nextern const uint16_t wuffs_base__low_bits_mask__u16[17];\nextern const uint32_t wuffs_base__low_bits_mask__u32[33];\nextern const uint64_t wuffs_base__low_bits_mask__u64[65];\n\n#define WUFFS_BASE__LOW_BITS_MASK__U8(n) (wuffs_base__low_bits_mask__u8[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U16(n) (wuffs_base__low_bits_mask__u16[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U32(n) (wuffs_base__low_bits_mask__u32[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U64(n) (wuffs_base__low_bits_mask__u64[n])\n\n" + + "// ---------------- Numeric Types\n\nextern const uint8_t wuffs_base__low_bits_mask__u8[9];\nextern const uint16_t wuffs_base__low_bits_mask__u16[17];\nextern const uint32_t wuffs_base__low_bits_mask__u32[33];\nextern const uint64_t wuffs_base__low_bits_mask__u64[65];\n\n#define WUFFS_BASE__LOW_BITS_MASK__U8(n) (wuffs_base__low_bits_mask__u8[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U16(n) (wuffs_base__low_bits_mask__u16[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U32(n) (wuffs_base__low_bits_mask__u32[n])\n#define WUFFS_BASE__LOW_BITS_MASK__U64(n) (wuffs_base__low_bits_mask__u64[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" + "" + @@ -126,10 +117,21 @@ const baseCorePublicH = "" + "" + "// --------\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 //\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" + + "// ---------------- Numeric Types\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 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 //\nwuffs_base__u8__sat_add(uint8_t x, uint8_t y) {\n uint8_t res = (uint8_t)(x + y);\n res |= (uint8_t)(-(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 = (uint8_t)(x - y);\n res &= (uint8_t)(-(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 = (uint16_t)(x + y);\n res |= (uint16_t)(-(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 = (uint16_t)(x - y);\n res &= (uint16_t)(-(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 = (uint32_t)(x + y);\n res |= (uint32_t)(-(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 = (uint32_t)(x - y);\n res &= (uint32_t)(-(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 = (uint64_t)(x + y);\n res |= (uint64_t)(-(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 = (uint64_t)(x - y);\n res &= (uint64_t)(-(res <= x));\n return res;\n}\n\n" + + "_t res = (uint32_t)(x + y);\n res |= (uint32_t)(-(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 = (uint32_t)(x - y);\n res &= (uint32_t)(-(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 = (uint64_t)(x + y);\n res |= (uint64_t)(-(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 = (uint64_t)(x - y);\n res &= (uint64_t)(-(res <= x));\n return res;\n}\n\n " + + "" + + "// --------\n\n#define wuffs_base__load_u8be__no_bounds_check \\\n wuffs_base__load_u8__no_bounds_check\n#define wuffs_base__load_u8le__no_bounds_check \\\n wuffs_base__load_u8__no_bounds_check\n\nstatic inline uint8_t //\nwuffs_base__load_u8__no_bounds_check(uint8_t* p) {\n return p[0];\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16be__no_bounds_check(uint8_t* p) {\n return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0));\n}\n\nstatic inline uint16_t //\nwuffs_base__load_u16le__no_bounds_check(uint8_t* p) {\n return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8));\n}\n\nstatic inline uint32_t //\nwuffs_base__load_u24be__no_bounds_check(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__no_bounds_check(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__no_bounds_check(" + + "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__no_bounds_check(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline uint64_t //\nwuffs_base__load_u40be__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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 //\nwuffs_base__load_u56be__no_bounds_check(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__no_bounds_check(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__no_bounds_ch" + + "eck(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__no_bounds_check(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\n#define wuffs_base__store_u8be__no_bounds_check \\\n wuffs_base__store_u8__no_bounds_check\n#define wuffs_base__store_u8le__no_bounds_check \\\n wuffs_base__store_u8__no_bounds_check\n\nstatic inline void //\nwuffs_base__store_u8__no_bounds_check(uint8_t* p, uint8_t x) {\n p[0] = x;\n}\n\nstatic inline void //\nwuffs_base__store_u16be__no_bounds_check(uint8_t* p, uint16_t x) {\n p[0] = (uint8_t)(x >> 8);\n p[1] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u16le__no_bounds_check(uint8_t* p, uint16_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n}\n\nstatic inline void //\nwuffs_base__store_u24be__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 16);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u24le__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n}\n\nstatic inline void //\nwuffs_base__store_u32be__no_bounds_check(uint8_t* p," + + " uint32_t x) {\n p[0] = (uint8_t)(x >> 24);\n p[1] = (uint8_t)(x >> 16);\n p[2] = (uint8_t)(x >> 8);\n p[3] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u32le__no_bounds_check(uint8_t* p, uint32_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n}\n\nstatic inline void //\nwuffs_base__store_u40be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 32);\n p[1] = (uint8_t)(x >> 24);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 8);\n p[4] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u40le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n}\n\nstatic inline void //\nwuffs_base__store_u48be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 40);\n p[1] = (uint8_t)(x >> 32);\n p[2] = (uint8_t)(x >> 24);\n p[3] = (uint8_t)(x >> 16);\n p[4] " + + "= (uint8_t)(x >> 8);\n p[5] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u48le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n}\n\nstatic inline void //\nwuffs_base__store_u56be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 48);\n p[1] = (uint8_t)(x >> 40);\n p[2] = (uint8_t)(x >> 32);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 16);\n p[5] = (uint8_t)(x >> 8);\n p[6] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u56le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n}\n\nstatic inline void //\nwuffs_base__store_u64be__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 56);\n" + + " p[1] = (uint8_t)(x >> 48);\n p[2] = (uint8_t)(x >> 40);\n p[3] = (uint8_t)(x >> 32);\n p[4] = (uint8_t)(x >> 24);\n p[5] = (uint8_t)(x >> 16);\n p[6] = (uint8_t)(x >> 8);\n p[7] = (uint8_t)(x >> 0);\n}\n\nstatic inline void //\nwuffs_base__store_u64le__no_bounds_check(uint8_t* p, uint64_t x) {\n p[0] = (uint8_t)(x >> 0);\n p[1] = (uint8_t)(x >> 8);\n p[2] = (uint8_t)(x >> 16);\n p[3] = (uint8_t)(x >> 24);\n p[4] = (uint8_t)(x >> 32);\n p[5] = (uint8_t)(x >> 40);\n p[6] = (uint8_t)(x >> 48);\n p[7] = (uint8_t)(x >> 56);\n}\n\n" + "" + "// ---------------- Slices and Tables\n\n// WUFFS_BASE__SLICE is a 1-dimensional buffer.\n//\n// len measures a number of elements, not necessarily a size in bytes.\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// width height, and stride measure a number of elements, not necessarily a\n// size in bytes.\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(u" + "int8_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__TABLE(uint64_t) wuffs_base__table_u64;\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__make_slice_u8(uint8_t* ptr, size_t len) {\n wuffs_base__slice_u8 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u16 //\nwuffs_base__make_slice_u16(uint16_t* ptr, size_t len) {\n wuffs_base__slice_u16 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u32 //\nwuffs_base__make_slice_u32(uint32_t* ptr, size_t len) {\n wuffs_base__slice_u32 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u64 //\nwuffs_base__make_slice_u64(uint64_t* ptr, size_t len) {\n wuffs_base__slice_u64 ret;\n ret.ptr = ptr;\n ret.len = len;\n return ret;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__empty_slice_u8() {\n wuffs_base__slice_u8 ret;\n ret.ptr = NULL;\n" + @@ -216,8 +218,8 @@ const baseIOPrivateH = "" + " that:\n// - distance > 0\n// - distance <= (*ptr_iop_w - io1_w)\n// - length <= (io2_w - *ptr_iop_w)\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n32_from_history_fast(uint8_t** ptr_iop_w,\n uint8_t* io1_w,\n uint8_t* io2_w,\n uint32_t length,\n uint32_t distance) {\n uint8_t* p = *ptr_iop_w;\n uint8_t* q = p - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *p++ = *q++;\n *p++ = *q++;\n *p++ = *q++;\n }\n for (; n; n--) {\n *p++ = *q++;\n }\n *ptr_iop_w = p;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n32_from_reader(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t length,\n uint8_t** ptr_iop_r,\n " + " uint8_t* io2_r) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = length;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n uint8_t* iop_r = *ptr_iop_r;\n if (n > ((size_t)(io2_r - iop_r))) {\n n = (size_t)(io2_r - iop_r);\n }\n if (n > 0) {\n memmove(iop_w, iop_r, n);\n *ptr_iop_w += n;\n *ptr_iop_r += n;\n }\n return (uint32_t)(n);\n}\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint64_t)(n);\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n32_from_slice(uint8_t** ptr_iop_w,\n uint8_t* io2_w,\n uint32_t" + " length,\n wuffs_base__slice_u8 src) {\n uint8_t* iop_w = *ptr_iop_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(io2_w - iop_w))) {\n n = (size_t)(io2_w - iop_w);\n }\n if (n > 0) {\n memmove(iop_w, src.ptr, n);\n *ptr_iop_w += n;\n }\n return (uint32_t)(n);\n}\n\n// wuffs_base__io_reader__match7 returns whether the io_reader's upcoming bytes\n// start with the given prefix (up to 7 bytes long). It is peek-like, not\n// read-like, in that there are no side-effects.\n//\n// The low 3 bits of a hold the prefix length, n.\n//\n// The high 56 bits of a hold the prefix itself, in little-endian order. The\n// first prefix byte is in bits 8..=15, the second prefix byte is in bits\n// 16..=23, etc. The high (8 * (7 - n)) bits are ignored.\n//\n// There are three possible return values:\n// - 0 means success.\n// - 1 means inconclusive, equivalent to \"$short read\".\n// - 2 means failure.\nstatic inline uint32_t //\nwuffs_base__io_reader__match7(ui" + - "nt8_t* iop_r,\n uint8_t* io2_r,\n wuffs_base__io_buffer* r,\n uint64_t a) {\n uint32_t n = a & 7;\n a >>= 8;\n if ((io2_r - iop_r) >= 8) {\n uint64_t x = wuffs_base__load_u64le(iop_r);\n uint32_t shift = 8 * (8 - n);\n return ((a << shift) == (x << shift)) ? 0 : 2;\n }\n for (; n > 0; n--) {\n if (iop_r >= io2_r) {\n return (r && r->meta.closed) ? 2 : 1;\n } else if (*iop_r != ((uint8_t)(a))) {\n return 2;\n }\n iop_r++;\n a >>= 8;\n }\n return 0;\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_reader__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_r,\n uint8_t** ptr_io0_r,\n uint8_t** ptr_io1_r,\n uint8_t** ptr_io2_r,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_r" + - " = data.ptr;\n *ptr_io0_r = data.ptr;\n *ptr_io1_r = data.ptr;\n *ptr_io2_r = data.ptr + data.len;\n\n return b;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io2_r, uint64_t n) {\n if (n <= ((size_t)(io2_r - *ptr_iop_r))) {\n uint8_t* p = *ptr_iop_r;\n *ptr_iop_r += n;\n return wuffs_base__make_slice_u8(p, n);\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_writer__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_w,\n uint8_t** ptr_io0_w,\n uint8_t** ptr_io1_w,\n uint8_t** ptr_io2_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_w = data.ptr;\n *ptr_io0_w = data.ptr;\n *ptr_io1_w = data.ptr;\n *ptr_io2_w = data.ptr + data.len;\n\n return b;\n}\n\n" + + "nt8_t* iop_r,\n uint8_t* io2_r,\n wuffs_base__io_buffer* r,\n uint64_t a) {\n uint32_t n = a & 7;\n a >>= 8;\n if ((io2_r - iop_r) >= 8) {\n uint64_t x = wuffs_base__load_u64le__no_bounds_check(iop_r);\n uint32_t shift = 8 * (8 - n);\n return ((a << shift) == (x << shift)) ? 0 : 2;\n }\n for (; n > 0; n--) {\n if (iop_r >= io2_r) {\n return (r && r->meta.closed) ? 2 : 1;\n } else if (*iop_r != ((uint8_t)(a))) {\n return 2;\n }\n iop_r++;\n a >>= 8;\n }\n return 0;\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_reader__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_r,\n uint8_t** ptr_io0_r,\n uint8_t** ptr_io1_r,\n uint8_t** ptr_io2_r,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = fal" + + "se;\n\n *ptr_iop_r = data.ptr;\n *ptr_io0_r = data.ptr;\n *ptr_io1_r = data.ptr;\n *ptr_io2_r = data.ptr + data.len;\n\n return b;\n}\n\nstatic inline wuffs_base__slice_u8 //\nwuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io2_r, uint64_t n) {\n if (n <= ((size_t)(io2_r - *ptr_iop_r))) {\n uint8_t* p = *ptr_iop_r;\n *ptr_iop_r += n;\n return wuffs_base__make_slice_u8(p, n);\n }\n return wuffs_base__make_slice_u8(NULL, 0);\n}\n\nstatic inline wuffs_base__io_buffer* //\nwuffs_base__io_writer__set(wuffs_base__io_buffer* b,\n uint8_t** ptr_iop_w,\n uint8_t** ptr_io0_w,\n uint8_t** ptr_io1_w,\n uint8_t** ptr_io2_w,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n *ptr_iop_w = data.ptr;\n *ptr_io0_w = data.ptr;\n *ptr_io1_w = data.ptr;\n *ptr_io2_w = data.ptr + data.len;\n\n return b;\n}\n\n " + "" + "// ---------------- I/O (Utility)\n\n#define wuffs_base__utility__empty_io_reader wuffs_base__empty_io_reader\n#define wuffs_base__utility__empty_io_writer wuffs_base__empty_io_writer\n" + "" diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 77efc361..3ae5c6a7 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -318,6 +318,16 @@ typedef int64_t wuffs_base__flicks; // ---------------- Numeric Types +// The helpers below are functions, instead of macros, because their arguments +// can be an expression that we shouldn't evaluate more than once. +// +// They are static, so that linking multiple wuffs .o files won't complain about +// duplicate function definitions. +// +// They are explicitly marked inline, even if modern compilers don't use the +// inline attribute to guide optimizations such as inlining, to avoid the +// -Wunused-function warning, and we like to compile with -Wall -Werror. + static inline uint8_t // wuffs_base__u8__min(uint8_t x, uint8_t y) { return x < y ? x : y; @@ -422,6 +432,250 @@ wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) { return res; } + // -------- + +#define wuffs_base__load_u8be__no_bounds_check \ + wuffs_base__load_u8__no_bounds_check +#define wuffs_base__load_u8le__no_bounds_check \ + wuffs_base__load_u8__no_bounds_check + +static inline uint8_t // +wuffs_base__load_u8__no_bounds_check(uint8_t* p) { + return p[0]; +} + +static inline uint16_t // +wuffs_base__load_u16be__no_bounds_check(uint8_t* p) { + return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); +} + +static inline uint16_t // +wuffs_base__load_u16le__no_bounds_check(uint8_t* p) { + return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); +} + +static inline uint32_t // +wuffs_base__load_u24be__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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__no_bounds_check(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) | ((uint64_t)(p[7]) << 56); +} + + // -------- + +#define wuffs_base__store_u8be__no_bounds_check \ + wuffs_base__store_u8__no_bounds_check +#define wuffs_base__store_u8le__no_bounds_check \ + wuffs_base__store_u8__no_bounds_check + +static inline void // +wuffs_base__store_u8__no_bounds_check(uint8_t* p, uint8_t x) { + p[0] = x; +} + +static inline void // +wuffs_base__store_u16be__no_bounds_check(uint8_t* p, uint16_t x) { + p[0] = (uint8_t)(x >> 8); + p[1] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u16le__no_bounds_check(uint8_t* p, uint16_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); +} + +static inline void // +wuffs_base__store_u24be__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 16); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u24le__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); +} + +static inline void // +wuffs_base__store_u32be__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 24); + p[1] = (uint8_t)(x >> 16); + p[2] = (uint8_t)(x >> 8); + p[3] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u32le__no_bounds_check(uint8_t* p, uint32_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); +} + +static inline void // +wuffs_base__store_u40be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 32); + p[1] = (uint8_t)(x >> 24); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 8); + p[4] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u40le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); +} + +static inline void // +wuffs_base__store_u48be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 40); + p[1] = (uint8_t)(x >> 32); + p[2] = (uint8_t)(x >> 24); + p[3] = (uint8_t)(x >> 16); + p[4] = (uint8_t)(x >> 8); + p[5] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u48le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); + p[5] = (uint8_t)(x >> 40); +} + +static inline void // +wuffs_base__store_u56be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 48); + p[1] = (uint8_t)(x >> 40); + p[2] = (uint8_t)(x >> 32); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 16); + p[5] = (uint8_t)(x >> 8); + p[6] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u56le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); + p[5] = (uint8_t)(x >> 40); + p[6] = (uint8_t)(x >> 48); +} + +static inline void // +wuffs_base__store_u64be__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 56); + p[1] = (uint8_t)(x >> 48); + p[2] = (uint8_t)(x >> 40); + p[3] = (uint8_t)(x >> 32); + p[4] = (uint8_t)(x >> 24); + p[5] = (uint8_t)(x >> 16); + p[6] = (uint8_t)(x >> 8); + p[7] = (uint8_t)(x >> 0); +} + +static inline void // +wuffs_base__store_u64le__no_bounds_check(uint8_t* p, uint64_t x) { + p[0] = (uint8_t)(x >> 0); + p[1] = (uint8_t)(x >> 8); + p[2] = (uint8_t)(x >> 16); + p[3] = (uint8_t)(x >> 24); + p[4] = (uint8_t)(x >> 32); + p[5] = (uint8_t)(x >> 40); + p[6] = (uint8_t)(x >> 48); + p[7] = (uint8_t)(x >> 56); +} + // ---------------- Slices and Tables // WUFFS_BASE__SLICE is a 1-dimensional buffer. @@ -5962,252 +6216,8 @@ wuffs_base__ignore_status(wuffs_base__status z) { #define WUFFS_BASE__UNLIKELY(expr) (expr) #endif -// The helpers below are functions, instead of macros, because their arguments -// can be an expression that we shouldn't evaluate more than once. -// -// They are static, so that linking multiple wuffs .o files won't complain about -// duplicate function definitions. -// -// They are explicitly marked inline, even if modern compilers don't use the -// inline attribute to guide optimizations such as inlining, to avoid the -// -Wunused-function warning, and we like to compile with -Wall -Werror. - // ---------------- Numeric Types -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) { - return (uint16_t)(((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0)); -} - -static inline uint16_t // -wuffs_base__load_u16le(uint8_t* p) { - return (uint16_t)(((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8)); -} - -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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) { - 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) | ((uint64_t)(p[7]) << 56); -} - -// -------- - -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) { - p[0] = (uint8_t)(x >> 8); - p[1] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u16le(uint8_t* p, uint16_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); -} - -static inline void // -wuffs_base__store_u24be(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 16); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u24le(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); -} - -static inline void // -wuffs_base__store_u32be(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 24); - p[1] = (uint8_t)(x >> 16); - p[2] = (uint8_t)(x >> 8); - p[3] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u32le(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); -} - -static inline void // -wuffs_base__store_u40be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 32); - p[1] = (uint8_t)(x >> 24); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 8); - p[4] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u40le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); -} - -static inline void // -wuffs_base__store_u48be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 40); - p[1] = (uint8_t)(x >> 32); - p[2] = (uint8_t)(x >> 24); - p[3] = (uint8_t)(x >> 16); - p[4] = (uint8_t)(x >> 8); - p[5] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u48le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); - p[5] = (uint8_t)(x >> 40); -} - -static inline void // -wuffs_base__store_u56be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 48); - p[1] = (uint8_t)(x >> 40); - p[2] = (uint8_t)(x >> 32); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 16); - p[5] = (uint8_t)(x >> 8); - p[6] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u56le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); - p[5] = (uint8_t)(x >> 40); - p[6] = (uint8_t)(x >> 48); -} - -static inline void // -wuffs_base__store_u64be(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 56); - p[1] = (uint8_t)(x >> 48); - p[2] = (uint8_t)(x >> 40); - p[3] = (uint8_t)(x >> 32); - p[4] = (uint8_t)(x >> 24); - p[5] = (uint8_t)(x >> 16); - p[6] = (uint8_t)(x >> 8); - p[7] = (uint8_t)(x >> 0); -} - -static inline void // -wuffs_base__store_u64le(uint8_t* p, uint64_t x) { - p[0] = (uint8_t)(x >> 0); - p[1] = (uint8_t)(x >> 8); - p[2] = (uint8_t)(x >> 16); - p[3] = (uint8_t)(x >> 24); - p[4] = (uint8_t)(x >> 32); - p[5] = (uint8_t)(x >> 40); - p[6] = (uint8_t)(x >> 48); - p[7] = (uint8_t)(x >> 56); -} - -// -------- - extern const uint8_t wuffs_base__low_bits_mask__u8[9]; extern const uint16_t wuffs_base__low_bits_mask__u16[17]; extern const uint32_t wuffs_base__low_bits_mask__u32[33]; @@ -6536,7 +6546,7 @@ wuffs_base__io_reader__match7(uint8_t* iop_r, uint32_t n = a & 7; a >>= 8; if ((io2_r - iop_r) >= 8) { - uint64_t x = wuffs_base__load_u64le(iop_r); + uint64_t x = wuffs_base__load_u64le__no_bounds_check(iop_r); uint32_t shift = 8 * (8 - n); return ((a << shift) == (x << shift)) ? 0 : 2; } @@ -7317,13 +7327,14 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* b, case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: - return wuffs_base__load_u32le(row + (4 * ((size_t)x))); + return wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: { uint8_t* palette = b->private_impl.planes[3].ptr; - return wuffs_base__load_u32le(palette + (4 * ((size_t)row[x]))); + return wuffs_base__load_u32le__no_bounds_check(palette + + (4 * ((size_t)row[x]))); } // Common formats above. Rarer formats below. @@ -7334,11 +7345,13 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* b, case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: { uint8_t* palette = b->private_impl.planes[3].ptr; return wuffs_base__premul_u32_axxx( - wuffs_base__load_u32le(palette + (4 * ((size_t)row[x])))); + wuffs_base__load_u32le__no_bounds_check(palette + + (4 * ((size_t)row[x])))); } case WUFFS_BASE__PIXEL_FORMAT__BGR_565: { - uint16_t bgr = wuffs_base__load_u16le(row + (2 * ((size_t)x))); + uint16_t bgr = + wuffs_base__load_u16le__no_bounds_check(row + (2 * ((size_t)x))); uint32_t b5 = 0x1F & (bgr >> 0); uint32_t b = (b5 << 3) | (b5 >> 2); uint32_t g6 = 0x3F & (bgr >> 5); @@ -7348,27 +7361,31 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* b, return 0xFF000000 | (r << 16) | (g << 8) | (b << 0); } case WUFFS_BASE__PIXEL_FORMAT__BGR: - return 0xFF000000 | wuffs_base__load_u24le(row + (3 * ((size_t)x))); + return 0xFF000000 | + wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__BGRX: - return 0xFF000000 | wuffs_base__load_u32le(row + (4 * ((size_t)x))); + return 0xFF000000 | + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: return wuffs_base__premul_u32_axxx( - wuffs_base__load_u32le(row + (4 * ((size_t)x)))); + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))); case WUFFS_BASE__PIXEL_FORMAT__RGB: return wuffs_base__swap_u32_argb_abgr( - 0xFF000000 | wuffs_base__load_u24le(row + (3 * ((size_t)x)))); + 0xFF000000 | + wuffs_base__load_u24le__no_bounds_check(row + (3 * ((size_t)x)))); case WUFFS_BASE__PIXEL_FORMAT__RGBX: return wuffs_base__swap_u32_argb_abgr( - 0xFF000000 | wuffs_base__load_u32le(row + (4 * ((size_t)x)))); + 0xFF000000 | + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))); case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: return wuffs_base__swap_u32_argb_abgr(wuffs_base__premul_u32_axxx( - wuffs_base__load_u32le(row + (4 * ((size_t)x))))); + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x))))); case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__RGBA_BINARY: return wuffs_base__swap_u32_argb_abgr( - wuffs_base__load_u32le(row + (4 * ((size_t)x)))); + wuffs_base__load_u32le__no_bounds_check(row + (4 * ((size_t)x)))); default: // TODO: support more formats. @@ -7404,7 +7421,7 @@ wuffs_base__pixel_buffer__set_color_u32_at( case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__BGRX: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), color); + wuffs_base__store_u32le__no_bounds_check(row + (4 * ((size_t)x)), color); break; // Common formats above. Rarer formats below. @@ -7414,31 +7431,32 @@ wuffs_base__pixel_buffer__set_color_u32_at( uint32_t g6 = 0x3F & (color >> (16 - 6)); uint32_t r5 = 0x1F & (color >> (24 - 5)); uint32_t bgr565 = (b5 << 0) | (g6 << 5) | (r5 << 11); - wuffs_base__store_u16le(row + (2 * ((size_t)x)), (uint16_t)bgr565); + wuffs_base__store_u16le__no_bounds_check(row + (2 * ((size_t)x)), + (uint16_t)bgr565); break; } case WUFFS_BASE__PIXEL_FORMAT__BGR: - wuffs_base__store_u24le(row + (3 * ((size_t)x)), color); + wuffs_base__store_u24le__no_bounds_check(row + (3 * ((size_t)x)), color); break; case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), - wuffs_base__nonpremul_u32_axxx(color)); + wuffs_base__store_u32le__no_bounds_check( + row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx(color)); break; case WUFFS_BASE__PIXEL_FORMAT__RGB: - wuffs_base__store_u24le(row + (3 * ((size_t)x)), - wuffs_base__swap_u32_argb_abgr(color)); + wuffs_base__store_u24le__no_bounds_check( + row + (3 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color)); break; case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), - wuffs_base__nonpremul_u32_axxx( - wuffs_base__swap_u32_argb_abgr(color))); + wuffs_base__store_u32le__no_bounds_check( + row + (4 * ((size_t)x)), wuffs_base__nonpremul_u32_axxx( + wuffs_base__swap_u32_argb_abgr(color))); break; case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: WUFFS_BASE__FALLTHROUGH; case WUFFS_BASE__PIXEL_FORMAT__RGBX: - wuffs_base__store_u32le(row + (4 * ((size_t)x)), - wuffs_base__swap_u32_argb_abgr(color)); + wuffs_base__store_u32le__no_bounds_check( + row + (4 * ((size_t)x)), wuffs_base__swap_u32_argb_abgr(color)); break; default: @@ -7466,9 +7484,9 @@ wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src( // TODO: unroll. while (n >= 1) { - uint32_t s0 = - wuffs_base__premul_u32_axxx(wuffs_base__load_u32le(s + (0 * 4))); - wuffs_base__store_u32le(d + (0 * 4), s0); + uint32_t s0 = wuffs_base__premul_u32_axxx( + wuffs_base__load_u32le__no_bounds_check(s + (0 * 4))); + wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0); s += 1 * 4; d += 1 * 4; @@ -7493,9 +7511,9 @@ wuffs_base__pixel_swizzler__bgra_premul__bgra_nonpremul__src_over( // TODO: unroll. while (n >= 1) { - uint32_t d0 = wuffs_base__load_u32le(d + (0 * 4)); - uint32_t s0 = wuffs_base__load_u32le(s + (0 * 4)); - wuffs_base__store_u32le( + uint32_t d0 = wuffs_base__load_u32le__no_bounds_check(d + (0 * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(s + (0 * 4)); + wuffs_base__store_u32le__no_bounds_check( d + (0 * 4), wuffs_base__composite_premul_nonpremul_u32_axxx(d0, s0)); s += 1 * 4; @@ -7542,18 +7560,18 @@ wuffs_base__pixel_swizzler__xx__index__src(wuffs_base__slice_u8 dst, const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - wuffs_base__store_u16le( - d + (0 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[0] * 4))); - wuffs_base__store_u16le( - d + (1 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[1] * 4))); - wuffs_base__store_u16le( - d + (2 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[2] * 4))); - wuffs_base__store_u16le( - d + (3 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[3] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (0 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (1 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[1] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (2 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[2] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (3 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[3] * 4))); s += loop_unroll_count * 1; d += loop_unroll_count * 2; @@ -7561,9 +7579,9 @@ wuffs_base__pixel_swizzler__xx__index__src(wuffs_base__slice_u8 dst, } while (n >= 1) { - wuffs_base__store_u16le( - d + (0 * 2), - wuffs_base__load_u16le(dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u16le__no_bounds_check( + d + (0 * 2), wuffs_base__load_u16le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); s += 1 * 1; d += 1 * 2; @@ -7595,18 +7613,18 @@ wuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst, // overwrite that with the correct byte. There is always another store, // whether a 4-byte store in this loop or a 1-byte store in the next loop. while (n > loop_unroll_count) { - wuffs_base__store_u32le( - d + (0 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4))); - wuffs_base__store_u32le( - d + (1 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4))); - wuffs_base__store_u32le( - d + (2 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4))); - wuffs_base__store_u32le( - d + (3 * 3), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (1 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[1] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (2 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[2] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (3 * 3), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[3] * 4))); s += loop_unroll_count * 1; d += loop_unroll_count * 3; @@ -7614,7 +7632,8 @@ wuffs_base__pixel_swizzler__xxx__index__src(wuffs_base__slice_u8 dst, } while (n >= 1) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); d[0] = (uint8_t)(s0 >> 0); d[1] = (uint8_t)(s0 >> 8); d[2] = (uint8_t)(s0 >> 16); @@ -7644,21 +7663,25 @@ wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over( const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u24le(d + (0 * 4), s0); + wuffs_base__store_u24le__no_bounds_check(d + (0 * 4), s0); } - uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)); + uint32_t s1 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[1] * 4)); if (s1) { - wuffs_base__store_u24le(d + (1 * 4), s1); + wuffs_base__store_u24le__no_bounds_check(d + (1 * 4), s1); } - uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)); + uint32_t s2 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[2] * 4)); if (s2) { - wuffs_base__store_u24le(d + (2 * 4), s2); + wuffs_base__store_u24le__no_bounds_check(d + (2 * 4), s2); } - uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)); + uint32_t s3 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[3] * 4)); if (s3) { - wuffs_base__store_u24le(d + (3 * 4), s3); + wuffs_base__store_u24le__no_bounds_check(d + (3 * 4), s3); } s += loop_unroll_count * 1; @@ -7667,9 +7690,10 @@ wuffs_base__pixel_swizzler__xxx__index_binary_alpha__src_over( } while (n >= 1) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u24le(d + (0 * 4), s0); + wuffs_base__store_u24le__no_bounds_check(d + (0 * 4), s0); } s += 1 * 1; @@ -7696,18 +7720,18 @@ wuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst, const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - wuffs_base__store_u32le( - d + (0 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4))); - wuffs_base__store_u32le( - d + (1 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4))); - wuffs_base__store_u32le( - d + (2 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4))); - wuffs_base__store_u32le( - d + (3 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (1 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[1] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (2 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[2] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (3 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[3] * 4))); s += loop_unroll_count * 1; d += loop_unroll_count * 4; @@ -7715,9 +7739,9 @@ wuffs_base__pixel_swizzler__xxxx__index__src(wuffs_base__slice_u8 dst, } while (n >= 1) { - wuffs_base__store_u32le( - d + (0 * 4), - wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), wuffs_base__load_u32le__no_bounds_check( + dst_palette.ptr + ((size_t)s[0] * 4))); s += 1 * 1; d += 1 * 4; @@ -7744,21 +7768,25 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( const size_t loop_unroll_count = 4; while (n >= loop_unroll_count) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u32le(d + (0 * 4), s0); + wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0); } - uint32_t s1 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[1] * 4)); + uint32_t s1 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[1] * 4)); if (s1) { - wuffs_base__store_u32le(d + (1 * 4), s1); + wuffs_base__store_u32le__no_bounds_check(d + (1 * 4), s1); } - uint32_t s2 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[2] * 4)); + uint32_t s2 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[2] * 4)); if (s2) { - wuffs_base__store_u32le(d + (2 * 4), s2); + wuffs_base__store_u32le__no_bounds_check(d + (2 * 4), s2); } - uint32_t s3 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[3] * 4)); + uint32_t s3 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[3] * 4)); if (s3) { - wuffs_base__store_u32le(d + (3 * 4), s3); + wuffs_base__store_u32le__no_bounds_check(d + (3 * 4), s3); } s += loop_unroll_count * 1; @@ -7767,9 +7795,10 @@ wuffs_base__pixel_swizzler__xxxx__index_binary_alpha__src_over( } while (n >= 1) { - uint32_t s0 = wuffs_base__load_u32le(dst_palette.ptr + ((size_t)s[0] * 4)); + uint32_t s0 = wuffs_base__load_u32le__no_bounds_check(dst_palette.ptr + + ((size_t)s[0] * 4)); if (s0) { - wuffs_base__store_u32le(d + (0 * 4), s0); + wuffs_base__store_u32le__no_bounds_check(d + (0 * 4), s0); } s += 1 * 1; @@ -7794,8 +7823,9 @@ wuffs_base__pixel_swizzler__xxxx__xxx(wuffs_base__slice_u8 dst, // TODO: unroll. while (n >= 1) { - wuffs_base__store_u32le(d + (0 * 4), - 0xFF000000 | wuffs_base__load_u24le(s + (0 * 3))); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), + 0xFF000000 | wuffs_base__load_u24le__no_bounds_check(s + (0 * 3))); s += 1 * 3; d += 1 * 4; @@ -7818,8 +7848,8 @@ wuffs_base__pixel_swizzler__xxxx__y(wuffs_base__slice_u8 dst, // TODO: unroll. while (n >= 1) { - wuffs_base__store_u32le(d + (0 * 4), - 0xFF000000 | (0x010101 * (uint32_t)s[0])); + wuffs_base__store_u32le__no_bounds_check( + d + (0 * 4), 0xFF000000 | (0x010101 * (uint32_t)s[0])); s += 1 * 1; d += 1 * 4; @@ -7840,11 +7870,12 @@ wuffs_base__pixel_swizzler__squash_bgr_565_888(wuffs_base__slice_u8 dst, size_t n = len4; while (n--) { - uint32_t argb = wuffs_base__load_u32le(s); + uint32_t argb = wuffs_base__load_u32le__no_bounds_check(s); uint32_t b5 = 0x1F & (argb >> (8 - 5)); uint32_t g6 = 0x3F & (argb >> (16 - 6)); uint32_t r5 = 0x1F & (argb >> (24 - 5)); - wuffs_base__store_u32le(d, (b5 << 0) | (g6 << 5) | (r5 << 11)); + wuffs_base__store_u32le__no_bounds_check( + d, (b5 << 0) | (g6 << 5) | (r5 << 11)); s += 4; d += 4; } @@ -8765,7 +8796,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -8811,7 +8842,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_1 = wuffs_base__load_u32le(iop_a_src); + t_1 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -8847,7 +8878,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); uint32_t t_2; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_2 = wuffs_base__load_u32le(iop_a_src); + t_2 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -8888,7 +8919,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); uint32_t t_3; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_3 = wuffs_base__load_u32le(iop_a_src); + t_3 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -8924,7 +8955,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); uint32_t t_4; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_4 = wuffs_base__load_u32le(iop_a_src); + t_4 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -8964,7 +8995,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); uint32_t t_5; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_5 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_5 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -8999,7 +9030,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(14); uint32_t t_6; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_6 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_6 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -9051,7 +9082,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(16); uint32_t t_7; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_7 = wuffs_base__load_u32le(iop_a_src); + t_7 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -9094,7 +9125,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(19); uint32_t t_8; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_8 = wuffs_base__load_u32le(iop_a_src); + t_8 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -9125,7 +9156,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(21); uint32_t t_9; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_9 = wuffs_base__load_u32le(iop_a_src); + t_9 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -9156,7 +9187,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(23); uint32_t t_10; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_10 = wuffs_base__load_u32le(iop_a_src); + t_10 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -9187,7 +9218,7 @@ wuffs_bmp__decoder__decode_image_config(wuffs_bmp__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(25); uint32_t t_11; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_11 = wuffs_base__load_u32le(iop_a_src); + t_11 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -11587,7 +11618,7 @@ wuffs_deflate__decoder__decode_uncompressed(wuffs_deflate__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_0 = wuffs_base__load_u32le(iop_a_src); + t_0 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_decode_uncompressed[0].scratch = 0; @@ -12306,10 +12337,12 @@ label__loop__continue:; while ((((uint64_t)(io2_a_dst - iop_a_dst)) >= 258) && (((uint64_t)(io2_a_src - iop_a_src)) >= 12)) { if (v_n_bits < 15) { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; } else { @@ -12319,8 +12352,8 @@ label__loop__continue:; v_bits >>= v_table_entry_n_bits; v_n_bits -= v_table_entry_n_bits; if ((v_table_entry >> 31) != 0) { - (wuffs_base__store_u8be(iop_a_dst, - ((uint8_t)(((v_table_entry >> 8) & 255)))), + (wuffs_base__store_u8be__no_bounds_check( + iop_a_dst, ((uint8_t)(((v_table_entry >> 8) & 255)))), iop_a_dst += 1, wuffs_base__make_empty_struct()); goto label__loop__continue; } else if ((v_table_entry >> 30) != 0) { @@ -12329,10 +12362,14 @@ label__loop__continue:; goto label__loop__break; } else if ((v_table_entry >> 28) != 0) { if (v_n_bits < 15) { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; } else { @@ -12346,8 +12383,8 @@ label__loop__continue:; v_bits >>= v_table_entry_n_bits; v_n_bits -= v_table_entry_n_bits; if ((v_table_entry >> 31) != 0) { - (wuffs_base__store_u8be(iop_a_dst, - ((uint8_t)(((v_table_entry >> 8) & 255)))), + (wuffs_base__store_u8be__no_bounds_check( + iop_a_dst, ((uint8_t)(((v_table_entry >> 8) & 255)))), iop_a_dst += 1, wuffs_base__make_empty_struct()); goto label__loop__continue; } else if ((v_table_entry >> 30) != 0) { @@ -12379,10 +12416,14 @@ label__loop__continue:; v_table_entry_n_bits = ((v_table_entry >> 4) & 15); if (v_table_entry_n_bits > 0) { if (v_n_bits < 15) { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; } else { @@ -12397,10 +12438,12 @@ label__loop__continue:; } else { } if (v_n_bits < 15) { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; } else { @@ -12411,10 +12454,14 @@ label__loop__continue:; v_n_bits -= v_table_entry_n_bits; if ((v_table_entry >> 28) == 1) { if (v_n_bits < 15) { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; } else { @@ -12442,10 +12489,12 @@ label__loop__continue:; v_dist_minus_1 = ((v_table_entry >> 8) & 32767); v_table_entry_n_bits = ((v_table_entry >> 4) & 15); if (v_n_bits < v_table_entry_n_bits) { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; } @@ -13236,14 +13285,17 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, while (true) { if (v_n_bits < v_width) { if (((uint64_t)(io2_a_src - iop_a_src)) >= 4) { - v_bits |= (wuffs_base__load_u32le(iop_a_src) << v_n_bits); + v_bits |= + (wuffs_base__load_u32le__no_bounds_check(iop_a_src) << v_n_bits); (iop_a_src += ((31 - v_n_bits) >> 3), wuffs_base__make_empty_struct()); v_n_bits |= 24; } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 0) { self->private_impl.f_read_from_return_value = 2; goto label__0__break; } else { - v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + v_bits |= + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; if (v_n_bits >= v_width) { @@ -13252,7 +13304,8 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self, goto label__0__break; } else { v_bits |= - (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); + (((uint32_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))) + << v_n_bits); (iop_a_src += 1, wuffs_base__make_empty_struct()); v_n_bits += 8; if (v_n_bits < v_width) { @@ -14048,7 +14101,7 @@ wuffs_gif__config_decoder__ack_metadata_chunk(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); } self->private_impl.f_metadata_chunk_length_value = - ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); if (self->private_impl.f_metadata_chunk_length_value > 0) { if (self->private_impl.f_metadata_fourcc_value == 1481461792) { self->private_impl.f_metadata_chunk_length_value += 1; @@ -14344,7 +14397,7 @@ wuffs_gif__config_decoder__decode_frame_config(wuffs_gif__config_decoder* self, status = wuffs_base__make_status(wuffs_base__suspension__short_read); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4); } - v_flags = wuffs_base__load_u8be(iop_a_src); + v_flags = wuffs_base__load_u8be__no_bounds_check(iop_a_src); if ((v_flags & 128) != 0) { v_background_color = self->private_impl.f_black_color_u32_argb_premul; } @@ -14784,7 +14837,7 @@ wuffs_gif__config_decoder__decode_lsd(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_lsd[0].scratch = 0; @@ -14814,7 +14867,7 @@ wuffs_gif__config_decoder__decode_lsd(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_1 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_lsd[0].scratch = 0; @@ -14873,7 +14926,8 @@ wuffs_gif__config_decoder__decode_lsd(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); uint32_t t_4; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) { - t_4 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src))); + t_4 = ((uint32_t)( + wuffs_base__load_u24be__no_bounds_check(iop_a_src))); iop_a_src += 3; } else { self->private_data.s_decode_lsd[0].scratch = 0; @@ -15283,7 +15337,8 @@ wuffs_gif__config_decoder__decode_ae(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); uint32_t t_4; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_4 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_4 = ((uint32_t)( + wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_ae[0].scratch = 0; @@ -15321,7 +15376,7 @@ wuffs_gif__config_decoder__decode_ae(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); } self->private_impl.f_metadata_chunk_length_value = - ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); (iop_a_src += 1, wuffs_base__make_empty_struct()); self->private_impl.f_metadata_fourcc_value = 1229144912; self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add( @@ -15337,7 +15392,7 @@ wuffs_gif__config_decoder__decode_ae(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); } self->private_impl.f_metadata_chunk_length_value = - ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); if (self->private_impl.f_metadata_chunk_length_value > 0) { self->private_impl.f_metadata_chunk_length_value += 1; } else { @@ -15455,7 +15510,7 @@ wuffs_gif__config_decoder__decode_gc(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint16_t t_2; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_2 = wuffs_base__load_u16le(iop_a_src); + t_2 = wuffs_base__load_u16le__no_bounds_check(iop_a_src); iop_a_src += 2; } else { self->private_data.s_decode_gc[0].scratch = 0; @@ -15554,7 +15609,7 @@ wuffs_gif__config_decoder__decode_id_part0(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -15584,7 +15639,7 @@ wuffs_gif__config_decoder__decode_id_part0(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_1 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -15614,7 +15669,7 @@ wuffs_gif__config_decoder__decode_id_part0(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); uint32_t t_2; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_2 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_2 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -15645,7 +15700,7 @@ wuffs_gif__config_decoder__decode_id_part0(wuffs_gif__config_decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); uint32_t t_3; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_3 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_3 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -15915,7 +15970,7 @@ wuffs_gif__decoder__ack_metadata_chunk(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1); } self->private_impl.f_metadata_chunk_length_value = - ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); if (self->private_impl.f_metadata_chunk_length_value > 0) { if (self->private_impl.f_metadata_fourcc_value == 1481461792) { self->private_impl.f_metadata_chunk_length_value += 1; @@ -16213,7 +16268,7 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self, status = wuffs_base__make_status(wuffs_base__suspension__short_read); WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4); } - v_flags = wuffs_base__load_u8be(iop_a_src); + v_flags = wuffs_base__load_u8be__no_bounds_check(iop_a_src); if ((v_flags & 128) != 0) { v_background_color = self->private_impl.f_black_color_u32_argb_premul; } @@ -16696,7 +16751,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_lsd[0].scratch = 0; @@ -16726,7 +16781,7 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_1 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_lsd[0].scratch = 0; @@ -16785,7 +16840,8 @@ wuffs_gif__decoder__decode_lsd(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); uint32_t t_4; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) { - t_4 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src))); + t_4 = ((uint32_t)( + wuffs_base__load_u24be__no_bounds_check(iop_a_src))); iop_a_src += 3; } else { self->private_data.s_decode_lsd[0].scratch = 0; @@ -17195,7 +17251,8 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); uint32_t t_4; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_4 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_4 = ((uint32_t)( + wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_ae[0].scratch = 0; @@ -17233,7 +17290,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(10); } self->private_impl.f_metadata_chunk_length_value = - ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); (iop_a_src += 1, wuffs_base__make_empty_struct()); self->private_impl.f_metadata_fourcc_value = 1229144912; self->private_impl.f_metadata_io_position = wuffs_base__u64__sat_add( @@ -17249,7 +17306,7 @@ wuffs_gif__decoder__decode_ae(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(11); } self->private_impl.f_metadata_chunk_length_value = - ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); if (self->private_impl.f_metadata_chunk_length_value > 0) { self->private_impl.f_metadata_chunk_length_value += 1; } else { @@ -17367,7 +17424,7 @@ wuffs_gif__decoder__decode_gc(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint16_t t_2; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_2 = wuffs_base__load_u16le(iop_a_src); + t_2 = wuffs_base__load_u16le__no_bounds_check(iop_a_src); iop_a_src += 2; } else { self->private_data.s_decode_gc[0].scratch = 0; @@ -17466,7 +17523,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint32_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_0 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_0 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -17496,7 +17553,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_1 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_1 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -17526,7 +17583,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); uint32_t t_2; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_2 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_2 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -17557,7 +17614,7 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); uint32_t t_3; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_3 = ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + t_3 = ((uint32_t)(wuffs_base__load_u16le__no_bounds_check(iop_a_src))); iop_a_src += 2; } else { self->private_data.s_decode_id_part0[0].scratch = 0; @@ -17676,7 +17733,8 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) { - t_1 = ((uint32_t)(wuffs_base__load_u24be(iop_a_src))); + t_1 = ((uint32_t)( + wuffs_base__load_u24be__no_bounds_check(iop_a_src))); iop_a_src += 3; } else { self->private_data.s_decode_id_part1[0].scratch = 0; @@ -17914,7 +17972,8 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self, v_need_block_size = true; goto label__0__break; } - v_block_size = ((uint64_t)(wuffs_base__load_u8be(iop_a_src))); + v_block_size = + ((uint64_t)(wuffs_base__load_u8be__no_bounds_check(iop_a_src))); (iop_a_src += 1, wuffs_base__make_empty_struct()); } label__0__break:; @@ -18486,7 +18545,7 @@ wuffs_gzip__decoder__transform_io(wuffs_gzip__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); uint16_t t_4; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_4 = wuffs_base__load_u16le(iop_a_src); + t_4 = wuffs_base__load_u16le__no_bounds_check(iop_a_src); iop_a_src += 2; } else { self->private_data.s_transform_io[0].scratch = 0; @@ -18617,7 +18676,7 @@ wuffs_gzip__decoder__transform_io(wuffs_gzip__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(13); uint32_t t_8; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_8 = wuffs_base__load_u32le(iop_a_src); + t_8 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_transform_io[0].scratch = 0; @@ -18647,7 +18706,7 @@ wuffs_gzip__decoder__transform_io(wuffs_gzip__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); uint32_t t_9; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_9 = wuffs_base__load_u32le(iop_a_src); + t_9 = wuffs_base__load_u32le__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_transform_io[0].scratch = 0; @@ -19014,7 +19073,7 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_whitespace_length = 0; goto label__outer__continue; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); v_class = wuffs_json__lut_classes[v_c]; if (v_class != 0) { goto label__ws__break; @@ -19061,7 +19120,7 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3); goto label__0__continue; } - if (wuffs_base__load_u8be(iop_a_src) != 92) { + if (wuffs_base__load_u8be__no_bounds_check(iop_a_src) != 92) { goto label__0__break; } if (((uint64_t)(io2_a_dst - iop_a_dst)) <= 0) { @@ -19107,7 +19166,7 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_string_length = 0; goto label__string_loop__continue; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); v_char = wuffs_json__lut_chars[v_c]; if (v_char == 0) { (iop_a_src += 1, wuffs_base__make_empty_struct()); @@ -19154,7 +19213,8 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_char = 0; goto label__string_loop__continue; } - v_c = ((uint8_t)((wuffs_base__load_u16le(iop_a_src) >> 8))); + v_c = ((uint8_t)( + (wuffs_base__load_u16le__no_bounds_check(iop_a_src) >> 8))); v_backslash = wuffs_json__lut_backslashes[v_c]; if (v_backslash > 0) { (iop_a_src += 2, wuffs_base__make_empty_struct()); @@ -19179,7 +19239,9 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, goto label__string_loop__continue; } v_uni4_string = - (((uint64_t)(wuffs_base__load_u48le(iop_a_src))) >> 16); + (((uint64_t)(wuffs_base__load_u48le__no_bounds_check( + iop_a_src))) >> + 16); v_uni4_value = 0; v_uni4_ok = 128; v_c = wuffs_json__lut_hexadecimal_digits[( @@ -19223,7 +19285,9 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, goto label__string_loop__continue; } (iop_a_src += 4, wuffs_base__make_empty_struct()); - v_uni4_string = (wuffs_base__load_u64le(iop_a_src) >> 16); + v_uni4_string = + (wuffs_base__load_u64le__no_bounds_check(iop_a_src) >> + 16); if (((255 & (v_uni4_string >> 0)) != 92) || ((255 & (v_uni4_string >> 8)) != 117)) { v_uni4_high_surrogate = 0; @@ -19296,8 +19360,8 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_char = 0; goto label__string_loop__continue; } - v_multi_byte_utf8 = - ((uint32_t)(wuffs_base__load_u16le(iop_a_src))); + v_multi_byte_utf8 = ((uint32_t)( + wuffs_base__load_u16le__no_bounds_check(iop_a_src))); if ((v_multi_byte_utf8 & 49152) == 32768) { v_multi_byte_utf8 = ((1984 & (v_multi_byte_utf8 << 6)) | (63 & (v_multi_byte_utf8 >> 8))); @@ -19328,8 +19392,8 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_char = 0; goto label__string_loop__continue; } - v_multi_byte_utf8 = - ((uint32_t)(wuffs_base__load_u24le(iop_a_src))); + v_multi_byte_utf8 = ((uint32_t)( + wuffs_base__load_u24le__no_bounds_check(iop_a_src))); if ((v_multi_byte_utf8 & 12632064) == 8421376) { v_multi_byte_utf8 = ((61440 & (v_multi_byte_utf8 << 12)) | (4032 & (v_multi_byte_utf8 >> 2)) | @@ -19365,7 +19429,8 @@ wuffs_json__decoder__decode_tokens(wuffs_json__decoder* self, v_char = 0; goto label__string_loop__continue; } - v_multi_byte_utf8 = wuffs_base__load_u32le(iop_a_src); + v_multi_byte_utf8 = + wuffs_base__load_u32le__no_bounds_check(iop_a_src); if ((v_multi_byte_utf8 & 3233857536) == 2155905024) { v_multi_byte_utf8 = ((1835008 & (v_multi_byte_utf8 << 18)) | (258048 & (v_multi_byte_utf8 << 4)) | @@ -19740,7 +19805,7 @@ wuffs_json__decoder__decode_number(wuffs_json__decoder* self, } goto label__goto_done__break; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); if (v_c != 45) { } else { v_n += 1; @@ -19752,7 +19817,7 @@ wuffs_json__decoder__decode_number(wuffs_json__decoder* self, v_n |= 256; goto label__goto_done__break; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); } if (v_c == 48) { v_n += 1; @@ -19775,7 +19840,7 @@ wuffs_json__decoder__decode_number(wuffs_json__decoder* self, } goto label__goto_done__break; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); if (v_c != 46) { } else { v_floating_point = 128; @@ -19797,7 +19862,7 @@ wuffs_json__decoder__decode_number(wuffs_json__decoder* self, } goto label__goto_done__break; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); } if ((v_c != 69) && (v_c != 101)) { goto label__goto_done__break; @@ -19812,7 +19877,7 @@ wuffs_json__decoder__decode_number(wuffs_json__decoder* self, v_n |= 256; goto label__goto_done__break; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); if ((v_c != 43) && (v_c != 45)) { } else { v_n += 1; @@ -19862,7 +19927,7 @@ wuffs_json__decoder__decode_digits(wuffs_json__decoder* self, } goto label__0__break; } - v_c = wuffs_base__load_u8be(iop_a_src); + v_c = wuffs_base__load_u8be__no_bounds_check(iop_a_src); if ((v_c < 48) || (57 < v_c)) { goto label__0__break; } @@ -20937,7 +21002,7 @@ wuffs_zlib__decoder__transform_io(wuffs_zlib__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); uint16_t t_0; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { - t_0 = wuffs_base__load_u16be(iop_a_src); + t_0 = wuffs_base__load_u16be__no_bounds_check(iop_a_src); iop_a_src += 2; } else { self->private_data.s_transform_io[0].scratch = 0; @@ -20984,7 +21049,7 @@ wuffs_zlib__decoder__transform_io(wuffs_zlib__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); uint32_t t_1; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_1 = wuffs_base__load_u32be(iop_a_src); + t_1 = wuffs_base__load_u32be__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_transform_io[0].scratch = 0; @@ -21064,7 +21129,7 @@ wuffs_zlib__decoder__transform_io(wuffs_zlib__decoder* self, WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6); uint32_t t_3; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_3 = wuffs_base__load_u32be(iop_a_src); + t_3 = wuffs_base__load_u32be__no_bounds_check(iop_a_src); iop_a_src += 4; } else { self->private_data.s_transform_io[0].scratch = 0; diff --git a/script/print-json-token-debug-format.c b/script/print-json-token-debug-format.c index 851e513f..af38a958 100644 --- a/script/print-json-token-debug-format.c +++ b/script/print-json-token-debug-format.c @@ -82,14 +82,6 @@ wuffs_base__token_buffer tok; wuffs_json__decoder dec; wuffs_base__status dec_status; -static inline void // -store_u32be(uint8_t* p, uint32_t x) { - p[0] = (uint8_t)(x >> 24); - p[1] = (uint8_t)(x >> 16); - p[2] = (uint8_t)(x >> 8); - p[3] = (uint8_t)(x >> 0); -} - #define TRY(error_msg) \ do { \ const char* z = error_msg; \ @@ -145,14 +137,14 @@ main1(int argc, char** argv) { uint64_t len = wuffs_base__token__length(t); if (wuffs_base__token__value(t) != 0) { - uint64_t major = wuffs_base__token__value_major(t); - uint64_t minor = wuffs_base__token__value_minor(t); + uint64_t maj = wuffs_base__token__value_major(t); + uint64_t min = wuffs_base__token__value_minor(t); uint8_t buf[16]; - store_u32be(&buf[0 * 4], (uint32_t)(pos)); - store_u32be(&buf[1 * 4], (uint32_t)(len)); - store_u32be(&buf[2 * 4], (uint32_t)(major)); - store_u32be(&buf[3 * 4], (uint32_t)(minor)); + wuffs_base__store_u32be__no_bounds_check(&buf[0 * 4], (uint32_t)(pos)); + wuffs_base__store_u32be__no_bounds_check(&buf[1 * 4], (uint32_t)(len)); + wuffs_base__store_u32be__no_bounds_check(&buf[2 * 4], (uint32_t)(maj)); + wuffs_base__store_u32be__no_bounds_check(&buf[3 * 4], (uint32_t)(min)); const int stdout_fd = 1; write(stdout_fd, &buf[0], 16); } diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index 47755efb..91327942 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -1001,7 +1001,7 @@ do_test__wuffs_base__image_decoder( RETURN_FAIL("pixbuf_len too large"); } else { wuffs_base__color_u32_argb_premul have_final_pixel = - wuffs_base__load_u32le(&global_pixel_array[n - 4]); + wuffs_base__load_u32le__no_bounds_check(&global_pixel_array[n - 4]); if (have_final_pixel != want_final_pixel) { RETURN_FAIL("final pixel: have 0x%08" PRIX32 ", want 0x%08" PRIX32, have_final_pixel, want_final_pixel); @@ -1092,8 +1092,8 @@ do_test__wuffs_base__token_decoder(wuffs_base__token_decoder* b, uint64_t len = wuffs_base__token__length(t); if (wuffs_base__token__value(t) != 0) { - uint64_t major = wuffs_base__token__value_major(t); - uint64_t minor = wuffs_base__token__value_minor(t); + uint64_t maj = wuffs_base__token__value_major(t); + uint64_t min = wuffs_base__token__value_minor(t); if ((have.data.len - have.meta.wi) < 16) { return "testlib: output is too long"; @@ -1101,10 +1101,10 @@ do_test__wuffs_base__token_decoder(wuffs_base__token_decoder* b, // This 16-bytes-per-token debug format is the same one used by // `script/print-json-token-debug-format.c`. uint8_t* ptr = have.data.ptr + have.meta.wi; - wuffs_base__store_u32be(ptr + (0 * 4), (uint32_t)(pos)); - wuffs_base__store_u32be(ptr + (1 * 4), (uint32_t)(len)); - wuffs_base__store_u32be(ptr + (2 * 4), (uint32_t)(major)); - wuffs_base__store_u32be(ptr + (3 * 4), (uint32_t)(minor)); + wuffs_base__store_u32be__no_bounds_check(ptr + (0 * 4), (uint32_t)(pos)); + wuffs_base__store_u32be__no_bounds_check(ptr + (1 * 4), (uint32_t)(len)); + wuffs_base__store_u32be__no_bounds_check(ptr + (2 * 4), (uint32_t)(maj)); + wuffs_base__store_u32be__no_bounds_check(ptr + (3 * 4), (uint32_t)(min)); have.meta.wi += 16; }