Place base func names at line start

This commit is contained in:
Nigel Tao committed 2018-07-14 11:35:00 +10:00
1 parent fa95380a23
commit caa55fe101
5 files changed
+1137 -920

No files matched your search

+534 -427
View File
@@ -145,19 +145,23 @@ typedef int32_t wuffs_base__status;
#define WUFFS_BASE__SUSPENSION_SHORT_READ 33554432 // 0x02000000
#define WUFFS_BASE__SUSPENSION_SHORT_WRITE 50331648 // 0x03000000
static inline bool wuffs_base__status__is_error(wuffs_base__status s) {
static inline bool //
wuffs_base__status__is_error(wuffs_base__status s) {
return s < 0;
}
static inline bool wuffs_base__status__is_ok(wuffs_base__status s) {
static inline bool //
wuffs_base__status__is_ok(wuffs_base__status s) {
return s == 0;
}
static inline bool wuffs_base__status__is_suspension(wuffs_base__status s) {
static inline bool //
wuffs_base__status__is_suspension(wuffs_base__status s) {
return s > 0;
}
const char* wuffs_base__status__string(wuffs_base__status s);
const char* //
wuffs_base__status__string(wuffs_base__status s);
// --------
@@ -170,35 +174,43 @@ typedef int64_t wuffs_base__flicks;
// ---------------- Numeric Types
static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) {
static inline uint8_t //
wuffs_base__u8__min(uint8_t x, uint8_t y) {
return x < y ? x : y;
}
static inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) {
static inline uint8_t //
wuffs_base__u8__max(uint8_t x, uint8_t y) {
return x > y ? x : y;
}
static inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) {
static inline uint16_t //
wuffs_base__u16__min(uint16_t x, uint16_t y) {
return x < y ? x : y;
}
static inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) {
static inline uint16_t //
wuffs_base__u16__max(uint16_t x, uint16_t y) {
return x > y ? x : y;
}
static inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) {
static inline uint32_t //
wuffs_base__u32__min(uint32_t x, uint32_t y) {
return x < y ? x : y;
}
static inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) {
static inline uint32_t //
wuffs_base__u32__max(uint32_t x, uint32_t y) {
return x > y ? x : y;
}
static inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) {
static inline uint64_t //
wuffs_base__u64__min(uint64_t x, uint64_t y) {
return x < y ? x : y;
}
static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) {
static inline uint64_t //
wuffs_base__u64__max(uint64_t x, uint64_t y) {
return x > y ? x : y;
}
@@ -210,49 +222,57 @@ static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) {
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint8_t wuffs_base__u8__sat_add(uint8_t x, uint8_t y) {
static inline uint8_t //
wuffs_base__u8__sat_add(uint8_t x, uint8_t y) {
uint8_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint8_t wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {
static inline uint8_t //
wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) {
uint8_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint16_t wuffs_base__u16__sat_add(uint16_t x, uint16_t y) {
static inline uint16_t //
wuffs_base__u16__sat_add(uint16_t x, uint16_t y) {
uint16_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint16_t wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {
static inline uint16_t //
wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) {
uint16_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
static inline uint32_t //
wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
static inline uint32_t //
wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
static inline uint64_t //
wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
static inline uint64_t //
wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
@@ -262,7 +282,8 @@ static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
// Clang also defines "__GNUC__".
static inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) {
static inline uint16_t //
wuffs_base__u16__byte_swapped(uint16_t x) {
#if defined(__GNUC__)
return __builtin_bswap16(x);
#else
@@ -270,7 +291,8 @@ static inline uint16_t wuffs_base__u16__byte_swapped(uint16_t x) {
#endif
}
static inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) {
static inline uint32_t //
wuffs_base__u32__byte_swapped(uint32_t x) {
#if defined(__GNUC__)
return __builtin_bswap32(x);
#else
@@ -280,7 +302,8 @@ static inline uint32_t wuffs_base__u32__byte_swapped(uint32_t x) {
#endif
}
static inline uint64_t wuffs_base__u64__byte_swapped(uint64_t x) {
static inline uint64_t //
wuffs_base__u64__byte_swapped(uint64_t x) {
#if defined(__GNUC__)
return __builtin_bswap64(x);
#else
@@ -373,37 +396,38 @@ typedef struct wuffs_base__range_ii_u32__struct {
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32* r) {
static inline bool //
wuffs_base__range_ii_u32__is_empty(wuffs_base__range_ii_u32* r) {
return r->min_incl > r->max_incl;
}
static inline bool wuffs_base__range_ii_u32__equals(
wuffs_base__range_ii_u32* r,
wuffs_base__range_ii_u32 s) {
static inline bool //
wuffs_base__range_ii_u32__equals(wuffs_base__range_ii_u32* r,
wuffs_base__range_ii_u32 s) {
return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||
(wuffs_base__range_ii_u32__is_empty(r) &&
wuffs_base__range_ii_u32__is_empty(&s));
}
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32* r,
uint32_t x) {
static inline bool //
wuffs_base__range_ii_u32__contains(wuffs_base__range_ii_u32* r, uint32_t x) {
return (r->min_incl <= x) && (x <= r->max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersect(
wuffs_base__range_ii_u32* r,
wuffs_base__range_ii_u32 s) {
static inline //
wuffs_base__range_ii_u32
wuffs_base__range_ii_u32__intersect(wuffs_base__range_ii_u32* r,
wuffs_base__range_ii_u32 s) {
wuffs_base__range_ii_u32 t;
t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);
t.max_incl = wuffs_base__u32__min(r->max_incl, s.max_incl);
return t;
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite(
wuffs_base__range_ii_u32* r,
wuffs_base__range_ii_u32 s) {
static inline //
wuffs_base__range_ii_u32
wuffs_base__range_ii_u32__unite(wuffs_base__range_ii_u32* r,
wuffs_base__range_ii_u32 s) {
if (wuffs_base__range_ii_u32__is_empty(r)) {
return s;
}
@@ -418,25 +442,28 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__unite(
#ifdef __cplusplus
inline bool wuffs_base__range_ii_u32::is_empty() {
inline bool //
wuffs_base__range_ii_u32::is_empty() {
return wuffs_base__range_ii_u32__is_empty(this);
}
inline bool wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) {
inline bool //
wuffs_base__range_ii_u32::equals(wuffs_base__range_ii_u32 s) {
return wuffs_base__range_ii_u32__equals(this, s);
}
inline bool wuffs_base__range_ii_u32::contains(uint32_t x) {
inline bool //
wuffs_base__range_ii_u32::contains(uint32_t x) {
return wuffs_base__range_ii_u32__contains(this, x);
}
inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::intersect(
wuffs_base__range_ii_u32 s) {
inline wuffs_base__range_ii_u32 //
wuffs_base__range_ii_u32::intersect(wuffs_base__range_ii_u32 s) {
return wuffs_base__range_ii_u32__intersect(this, s);
}
inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32::unite(
wuffs_base__range_ii_u32 s) {
inline wuffs_base__range_ii_u32 //
wuffs_base__range_ii_u32::unite(wuffs_base__range_ii_u32 s) {
return wuffs_base__range_ii_u32__unite(this, s);
}
@@ -461,37 +488,36 @@ typedef struct wuffs_base__range_ie_u32__struct {
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32* r) {
static inline bool //
wuffs_base__range_ie_u32__is_empty(wuffs_base__range_ie_u32* r) {
return r->min_incl >= r->max_excl;
}
static inline bool wuffs_base__range_ie_u32__equals(
wuffs_base__range_ie_u32* r,
wuffs_base__range_ie_u32 s) {
static inline bool //
wuffs_base__range_ie_u32__equals(wuffs_base__range_ie_u32* r,
wuffs_base__range_ie_u32 s) {
return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||
(wuffs_base__range_ie_u32__is_empty(r) &&
wuffs_base__range_ie_u32__is_empty(&s));
}
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32* r,
uint32_t x) {
static inline bool //
wuffs_base__range_ie_u32__contains(wuffs_base__range_ie_u32* r, uint32_t x) {
return (r->min_incl <= x) && (x < r->max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersect(
wuffs_base__range_ie_u32* r,
wuffs_base__range_ie_u32 s) {
static inline wuffs_base__range_ie_u32 //
wuffs_base__range_ie_u32__intersect(wuffs_base__range_ie_u32* r,
wuffs_base__range_ie_u32 s) {
wuffs_base__range_ie_u32 t;
t.min_incl = wuffs_base__u32__max(r->min_incl, s.min_incl);
t.max_excl = wuffs_base__u32__min(r->max_excl, s.max_excl);
return t;
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite(
wuffs_base__range_ie_u32* r,
wuffs_base__range_ie_u32 s) {
static inline wuffs_base__range_ie_u32 //
wuffs_base__range_ie_u32__unite(wuffs_base__range_ie_u32* r,
wuffs_base__range_ie_u32 s) {
if (wuffs_base__range_ie_u32__is_empty(r)) {
return s;
}
@@ -504,36 +530,40 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__unite(
return t;
}
static inline uint32_t wuffs_base__range_ie_u32__length(
wuffs_base__range_ie_u32* r) {
static inline uint32_t //
wuffs_base__range_ie_u32__length(wuffs_base__range_ie_u32* r) {
return wuffs_base__u32__sat_sub(r->max_excl, r->min_incl);
}
#ifdef __cplusplus
inline bool wuffs_base__range_ie_u32::is_empty() {
inline bool //
wuffs_base__range_ie_u32::is_empty() {
return wuffs_base__range_ie_u32__is_empty(this);
}
inline bool wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) {
inline bool //
wuffs_base__range_ie_u32::equals(wuffs_base__range_ie_u32 s) {
return wuffs_base__range_ie_u32__equals(this, s);
}
inline bool wuffs_base__range_ie_u32::contains(uint32_t x) {
inline bool //
wuffs_base__range_ie_u32::contains(uint32_t x) {
return wuffs_base__range_ie_u32__contains(this, x);
}
inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::intersect(
wuffs_base__range_ie_u32 s) {
inline wuffs_base__range_ie_u32 //
wuffs_base__range_ie_u32::intersect(wuffs_base__range_ie_u32 s) {
return wuffs_base__range_ie_u32__intersect(this, s);
}
inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32::unite(
wuffs_base__range_ie_u32 s) {
inline wuffs_base__range_ie_u32 //
wuffs_base__range_ie_u32::unite(wuffs_base__range_ie_u32 s) {
return wuffs_base__range_ie_u32__unite(this, s);
}
inline uint32_t wuffs_base__range_ie_u32::length() {
inline uint32_t //
wuffs_base__range_ie_u32::length() {
return wuffs_base__range_ie_u32__length(this);
}
@@ -557,37 +587,36 @@ typedef struct wuffs_base__range_ii_u64__struct {
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64* r) {
static inline bool //
wuffs_base__range_ii_u64__is_empty(wuffs_base__range_ii_u64* r) {
return r->min_incl > r->max_incl;
}
static inline bool wuffs_base__range_ii_u64__equals(
wuffs_base__range_ii_u64* r,
wuffs_base__range_ii_u64 s) {
static inline bool //
wuffs_base__range_ii_u64__equals(wuffs_base__range_ii_u64* r,
wuffs_base__range_ii_u64 s) {
return (r->min_incl == s.min_incl && r->max_incl == s.max_incl) ||
(wuffs_base__range_ii_u64__is_empty(r) &&
wuffs_base__range_ii_u64__is_empty(&s));
}
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64* r,
uint64_t x) {
static inline bool //
wuffs_base__range_ii_u64__contains(wuffs_base__range_ii_u64* r, uint64_t x) {
return (r->min_incl <= x) && (x <= r->max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersect(
wuffs_base__range_ii_u64* r,
wuffs_base__range_ii_u64 s) {
static inline wuffs_base__range_ii_u64 //
wuffs_base__range_ii_u64__intersect(wuffs_base__range_ii_u64* r,
wuffs_base__range_ii_u64 s) {
wuffs_base__range_ii_u64 t;
t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);
t.max_incl = wuffs_base__u64__min(r->max_incl, s.max_incl);
return t;
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite(
wuffs_base__range_ii_u64* r,
wuffs_base__range_ii_u64 s) {
static inline wuffs_base__range_ii_u64 //
wuffs_base__range_ii_u64__unite(wuffs_base__range_ii_u64* r,
wuffs_base__range_ii_u64 s) {
if (wuffs_base__range_ii_u64__is_empty(r)) {
return s;
}
@@ -602,25 +631,28 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__unite(
#ifdef __cplusplus
inline bool wuffs_base__range_ii_u64::is_empty() {
inline bool //
wuffs_base__range_ii_u64::is_empty() {
return wuffs_base__range_ii_u64__is_empty(this);
}
inline bool wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) {
inline bool //
wuffs_base__range_ii_u64::equals(wuffs_base__range_ii_u64 s) {
return wuffs_base__range_ii_u64__equals(this, s);
}
inline bool wuffs_base__range_ii_u64::contains(uint64_t x) {
inline bool //
wuffs_base__range_ii_u64::contains(uint64_t x) {
return wuffs_base__range_ii_u64__contains(this, x);
}
inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::intersect(
wuffs_base__range_ii_u64 s) {
inline wuffs_base__range_ii_u64 //
wuffs_base__range_ii_u64::intersect(wuffs_base__range_ii_u64 s) {
return wuffs_base__range_ii_u64__intersect(this, s);
}
inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64::unite(
wuffs_base__range_ii_u64 s) {
inline wuffs_base__range_ii_u64 //
wuffs_base__range_ii_u64::unite(wuffs_base__range_ii_u64 s) {
return wuffs_base__range_ii_u64__unite(this, s);
}
@@ -645,37 +677,36 @@ typedef struct wuffs_base__range_ie_u64__struct {
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64* r) {
static inline bool //
wuffs_base__range_ie_u64__is_empty(wuffs_base__range_ie_u64* r) {
return r->min_incl >= r->max_excl;
}
static inline bool wuffs_base__range_ie_u64__equals(
wuffs_base__range_ie_u64* r,
wuffs_base__range_ie_u64 s) {
static inline bool //
wuffs_base__range_ie_u64__equals(wuffs_base__range_ie_u64* r,
wuffs_base__range_ie_u64 s) {
return (r->min_incl == s.min_incl && r->max_excl == s.max_excl) ||
(wuffs_base__range_ie_u64__is_empty(r) &&
wuffs_base__range_ie_u64__is_empty(&s));
}
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64* r,
uint64_t x) {
static inline bool //
wuffs_base__range_ie_u64__contains(wuffs_base__range_ie_u64* r, uint64_t x) {
return (r->min_incl <= x) && (x < r->max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersect(
wuffs_base__range_ie_u64* r,
wuffs_base__range_ie_u64 s) {
static inline wuffs_base__range_ie_u64 //
wuffs_base__range_ie_u64__intersect(wuffs_base__range_ie_u64* r,
wuffs_base__range_ie_u64 s) {
wuffs_base__range_ie_u64 t;
t.min_incl = wuffs_base__u64__max(r->min_incl, s.min_incl);
t.max_excl = wuffs_base__u64__min(r->max_excl, s.max_excl);
return t;
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite(
wuffs_base__range_ie_u64* r,
wuffs_base__range_ie_u64 s) {
static inline wuffs_base__range_ie_u64 //
wuffs_base__range_ie_u64__unite(wuffs_base__range_ie_u64* r,
wuffs_base__range_ie_u64 s) {
if (wuffs_base__range_ie_u64__is_empty(r)) {
return s;
}
@@ -688,36 +719,40 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__unite(
return t;
}
static inline uint64_t wuffs_base__range_ie_u64__length(
wuffs_base__range_ie_u64* r) {
static inline uint64_t //
wuffs_base__range_ie_u64__length(wuffs_base__range_ie_u64* r) {
return wuffs_base__u64__sat_sub(r->max_excl, r->min_incl);
}
#ifdef __cplusplus
inline bool wuffs_base__range_ie_u64::is_empty() {
inline bool //
wuffs_base__range_ie_u64::is_empty() {
return wuffs_base__range_ie_u64__is_empty(this);
}
inline bool wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) {
inline bool //
wuffs_base__range_ie_u64::equals(wuffs_base__range_ie_u64 s) {
return wuffs_base__range_ie_u64__equals(this, s);
}
inline bool wuffs_base__range_ie_u64::contains(uint64_t x) {
inline bool //
wuffs_base__range_ie_u64::contains(uint64_t x) {
return wuffs_base__range_ie_u64__contains(this, x);
}
inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::intersect(
wuffs_base__range_ie_u64 s) {
inline wuffs_base__range_ie_u64 //
wuffs_base__range_ie_u64::intersect(wuffs_base__range_ie_u64 s) {
return wuffs_base__range_ie_u64__intersect(this, s);
}
inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64::unite(
wuffs_base__range_ie_u64 s) {
inline wuffs_base__range_ie_u64 //
wuffs_base__range_ie_u64::unite(wuffs_base__range_ie_u64 s) {
return wuffs_base__range_ie_u64__unite(this, s);
}
inline uint64_t wuffs_base__range_ie_u64::length() {
inline uint64_t //
wuffs_base__range_ie_u64::length() {
return wuffs_base__range_ie_u64__length(this);
}
@@ -752,29 +787,31 @@ typedef struct wuffs_base__rect_ii_u32__struct {
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32* r) {
static inline bool //
wuffs_base__rect_ii_u32__is_empty(wuffs_base__rect_ii_u32* r) {
return (r->min_incl_x > r->max_incl_x) || (r->min_incl_y > r->max_incl_y);
}
static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r,
wuffs_base__rect_ii_u32 s) {
static inline bool //
wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32* r,
wuffs_base__rect_ii_u32 s) {
return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&
r->max_incl_x == s.max_incl_x && r->max_incl_y == s.max_incl_y) ||
(wuffs_base__rect_ii_u32__is_empty(r) &&
wuffs_base__rect_ii_u32__is_empty(&s));
}
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r,
uint32_t x,
uint32_t y) {
static inline bool //
wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32* r,
uint32_t x,
uint32_t y) {
return (r->min_incl_x <= x) && (x <= r->max_incl_x) && (r->min_incl_y <= y) &&
(y <= r->max_incl_y);
}
static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect(
wuffs_base__rect_ii_u32* r,
wuffs_base__rect_ii_u32 s) {
static inline wuffs_base__rect_ii_u32 //
wuffs_base__rect_ii_u32__intersect(wuffs_base__rect_ii_u32* r,
wuffs_base__rect_ii_u32 s) {
wuffs_base__rect_ii_u32 t;
t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);
t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);
@@ -783,9 +820,9 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersect(
return t;
}
static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite(
wuffs_base__rect_ii_u32* r,
wuffs_base__rect_ii_u32 s) {
static inline wuffs_base__rect_ii_u32 //
wuffs_base__rect_ii_u32__unite(wuffs_base__rect_ii_u32* r,
wuffs_base__rect_ii_u32 s) {
if (wuffs_base__rect_ii_u32__is_empty(r)) {
return s;
}
@@ -802,25 +839,28 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__unite(
#ifdef __cplusplus
inline bool wuffs_base__rect_ii_u32::is_empty() {
inline bool //
wuffs_base__rect_ii_u32::is_empty() {
return wuffs_base__rect_ii_u32__is_empty(this);
}
inline bool wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) {
inline bool //
wuffs_base__rect_ii_u32::equals(wuffs_base__rect_ii_u32 s) {
return wuffs_base__rect_ii_u32__equals(this, s);
}
inline bool wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) {
inline bool //
wuffs_base__rect_ii_u32::contains(uint32_t x, uint32_t y) {
return wuffs_base__rect_ii_u32__contains(this, x, y);
}
inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::intersect(
wuffs_base__rect_ii_u32 s) {
inline wuffs_base__rect_ii_u32 //
wuffs_base__rect_ii_u32::intersect(wuffs_base__rect_ii_u32 s) {
return wuffs_base__rect_ii_u32__intersect(this, s);
}
inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32::unite(
wuffs_base__rect_ii_u32 s) {
inline wuffs_base__rect_ii_u32 //
wuffs_base__rect_ii_u32::unite(wuffs_base__rect_ii_u32 s) {
return wuffs_base__rect_ii_u32__unite(this, s);
}
@@ -858,29 +898,31 @@ typedef struct wuffs_base__rect_ie_u32__struct {
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32* r) {
static inline bool //
wuffs_base__rect_ie_u32__is_empty(wuffs_base__rect_ie_u32* r) {
return (r->min_incl_x >= r->max_excl_x) || (r->min_incl_y >= r->max_excl_y);
}
static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r,
wuffs_base__rect_ie_u32 s) {
static inline bool //
wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32* r,
wuffs_base__rect_ie_u32 s) {
return (r->min_incl_x == s.min_incl_x && r->min_incl_y == s.min_incl_y &&
r->max_excl_x == s.max_excl_x && r->max_excl_y == s.max_excl_y) ||
(wuffs_base__rect_ie_u32__is_empty(r) &&
wuffs_base__rect_ie_u32__is_empty(&s));
}
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r,
uint32_t x,
uint32_t y) {
static inline bool //
wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32* r,
uint32_t x,
uint32_t y) {
return (r->min_incl_x <= x) && (x < r->max_excl_x) && (r->min_incl_y <= y) &&
(y < r->max_excl_y);
}
static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersect(
wuffs_base__rect_ie_u32* r,
wuffs_base__rect_ie_u32 s) {
static inline wuffs_base__rect_ie_u32 //
wuffs_base__rect_ie_u32__intersect(wuffs_base__rect_ie_u32* r,
wuffs_base__rect_ie_u32 s) {
wuffs_base__rect_ie_u32 t;
t.min_incl_x = wuffs_base__u32__max(r->min_incl_x, s.min_incl_x);
t.min_incl_y = wuffs_base__u32__max(r->min_incl_y, s.min_incl_y);
@@ -889,9 +931,9 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersect(
return t;
}
static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite(
wuffs_base__rect_ie_u32* r,
wuffs_base__rect_ie_u32 s) {
static inline wuffs_base__rect_ie_u32 //
wuffs_base__rect_ie_u32__unite(wuffs_base__rect_ie_u32* r,
wuffs_base__rect_ie_u32 s) {
if (wuffs_base__rect_ie_u32__is_empty(r)) {
return s;
}
@@ -906,45 +948,50 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__unite(
return t;
}
static inline uint32_t wuffs_base__rect_ie_u32__width(
wuffs_base__rect_ie_u32* r) {
static inline uint32_t //
wuffs_base__rect_ie_u32__width(wuffs_base__rect_ie_u32* r) {
return wuffs_base__u32__sat_sub(r->max_excl_x, r->min_incl_x);
}
static inline uint32_t wuffs_base__rect_ie_u32__height(
wuffs_base__rect_ie_u32* r) {
static inline uint32_t //
wuffs_base__rect_ie_u32__height(wuffs_base__rect_ie_u32* r) {
return wuffs_base__u32__sat_sub(r->max_excl_y, r->min_incl_y);
}
#ifdef __cplusplus
inline bool wuffs_base__rect_ie_u32::is_empty() {
inline bool //
wuffs_base__rect_ie_u32::is_empty() {
return wuffs_base__rect_ie_u32__is_empty(this);
}
inline bool wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) {
inline bool //
wuffs_base__rect_ie_u32::equals(wuffs_base__rect_ie_u32 s) {
return wuffs_base__rect_ie_u32__equals(this, s);
}
inline bool wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) {
inline bool //
wuffs_base__rect_ie_u32::contains(uint32_t x, uint32_t y) {
return wuffs_base__rect_ie_u32__contains(this, x, y);
}
inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::intersect(
wuffs_base__rect_ie_u32 s) {
inline wuffs_base__rect_ie_u32 //
wuffs_base__rect_ie_u32::intersect(wuffs_base__rect_ie_u32 s) {
return wuffs_base__rect_ie_u32__intersect(this, s);
}
inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32::unite(
wuffs_base__rect_ie_u32 s) {
inline wuffs_base__rect_ie_u32 //
wuffs_base__rect_ie_u32::unite(wuffs_base__rect_ie_u32 s) {
return wuffs_base__rect_ie_u32__unite(this, s);
}
inline uint32_t wuffs_base__rect_ie_u32::width() {
inline uint32_t //
wuffs_base__rect_ie_u32::width() {
return wuffs_base__rect_ie_u32__width(this);
}
inline uint32_t wuffs_base__rect_ie_u32::height() {
inline uint32_t //
wuffs_base__rect_ie_u32::height() {
return wuffs_base__rect_ie_u32__height(this);
}
@@ -999,7 +1046,8 @@ typedef struct wuffs_base__io_buffer__struct {
// wuffs_base__io_buffer__compact moves any written but unread bytes to the
// start of the buffer.
static inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {
static inline void //
wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {
if (!buf || (buf->ri == 0)) {
return;
}
@@ -1011,15 +1059,15 @@ static inline void wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {
buf->ri = 0;
}
static inline wuffs_base__io_reader wuffs_base__io_buffer__reader(
wuffs_base__io_buffer* buf) {
static inline wuffs_base__io_reader //
wuffs_base__io_buffer__reader(wuffs_base__io_buffer* buf) {
wuffs_base__io_reader ret = ((wuffs_base__io_reader){});
ret.private_impl.buf = buf;
return ret;
}
static inline wuffs_base__io_writer wuffs_base__io_buffer__writer(
wuffs_base__io_buffer* buf) {
static inline wuffs_base__io_writer //
wuffs_base__io_buffer__writer(wuffs_base__io_buffer* buf) {
wuffs_base__io_writer ret = ((wuffs_base__io_writer){});
ret.private_impl.buf = buf;
return ret;
@@ -1027,15 +1075,18 @@ static inline wuffs_base__io_writer wuffs_base__io_buffer__writer(
#ifdef __cplusplus
inline void wuffs_base__io_buffer__struct::compact() {
inline void //
wuffs_base__io_buffer__struct::compact() {
wuffs_base__io_buffer__compact(this);
}
inline wuffs_base__io_reader wuffs_base__io_buffer__struct::reader() {
inline wuffs_base__io_reader //
wuffs_base__io_buffer__struct::reader() {
return wuffs_base__io_buffer__reader(this);
}
inline wuffs_base__io_writer wuffs_base__io_buffer__struct::writer() {
inline wuffs_base__io_writer //
wuffs_base__io_buffer__struct::writer() {
return wuffs_base__io_buffer__writer(this);
}
@@ -1201,20 +1252,20 @@ typedef uint32_t wuffs_base__pixel_format;
#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)
#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)
static inline bool wuffs_base__pixel_format__is_valid(
wuffs_base__pixel_format f) {
static inline bool //
wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) {
return f != 0;
}
static inline bool wuffs_base__pixel_format__is_indexed(
wuffs_base__pixel_format f) {
static inline bool //
wuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) {
return ((f >> 16) & 0x0F) != 0;
}
#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4
static inline uint32_t wuffs_base__pixel_format__num_planes(
wuffs_base__pixel_format f) {
static inline uint32_t //
wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) {
return f ? (((f >> 20) & 0x03) + 1) : 0;
}
@@ -1274,30 +1325,30 @@ typedef uint32_t wuffs_base__pixel_subsampling;
#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \
((wuffs_base__pixel_subsampling)0x212100)
static inline uint32_t wuffs_base__pixel_subsampling__bias_x(
wuffs_base__pixel_subsampling s,
uint32_t plane) {
static inline uint32_t //
wuffs_base__pixel_subsampling__bias_x(wuffs_base__pixel_subsampling s,
uint32_t plane) {
uint32_t shift = ((plane & 0x03) * 8) + 6;
return (s >> shift) & 0x03;
}
static inline uint32_t wuffs_base__pixel_subsampling__shift_x(
wuffs_base__pixel_subsampling s,
uint32_t plane) {
static inline uint32_t //
wuffs_base__pixel_subsampling__shift_x(wuffs_base__pixel_subsampling s,
uint32_t plane) {
uint32_t shift = ((plane & 0x03) * 8) + 4;
return (s >> shift) & 0x03;
}
static inline uint32_t wuffs_base__pixel_subsampling__bias_y(
wuffs_base__pixel_subsampling s,
uint32_t plane) {
static inline uint32_t //
wuffs_base__pixel_subsampling__bias_y(wuffs_base__pixel_subsampling s,
uint32_t plane) {
uint32_t shift = ((plane & 0x03) * 8) + 2;
return (s >> shift) & 0x03;
}
static inline uint32_t wuffs_base__pixel_subsampling__shift_y(
wuffs_base__pixel_subsampling s,
uint32_t plane) {
static inline uint32_t //
wuffs_base__pixel_subsampling__shift_y(wuffs_base__pixel_subsampling s,
uint32_t plane) {
uint32_t shift = ((plane & 0x03) * 8) + 0;
return (s >> shift) & 0x03;
}
@@ -1338,14 +1389,14 @@ typedef struct {
} wuffs_base__image_config;
// TODO: Should this function return bool? An error type?
static inline void wuffs_base__image_config__initialize(
wuffs_base__image_config* c,
wuffs_base__pixel_format pixfmt,
wuffs_base__pixel_subsampling pixsub,
uint32_t width,
uint32_t height,
uint32_t num_loops,
bool first_frame_is_opaque) {
static inline void //
wuffs_base__image_config__initialize(wuffs_base__image_config* c,
wuffs_base__pixel_format pixfmt,
wuffs_base__pixel_subsampling pixsub,
uint32_t width,
uint32_t height,
uint32_t num_loops,
bool first_frame_is_opaque) {
if (!c) {
return;
}
@@ -1365,30 +1416,30 @@ static inline void wuffs_base__image_config__initialize(
*c = ((wuffs_base__image_config){});
}
static inline void wuffs_base__image_config__invalidate(
wuffs_base__image_config* c) {
static inline void //
wuffs_base__image_config__invalidate(wuffs_base__image_config* c) {
if (c) {
*c = ((wuffs_base__image_config){});
}
}
static inline bool wuffs_base__image_config__is_valid(
wuffs_base__image_config* c) {
static inline bool //
wuffs_base__image_config__is_valid(wuffs_base__image_config* c) {
return c && c->private_impl.pixfmt;
}
static inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(
wuffs_base__image_config* c) {
static inline wuffs_base__pixel_format //
wuffs_base__image_config__pixel_format(wuffs_base__image_config* c) {
return c ? c->private_impl.pixfmt : 0;
}
static inline wuffs_base__pixel_subsampling
static inline wuffs_base__pixel_subsampling //
wuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {
return c ? c->private_impl.pixsub : 0;
}
static inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds(
wuffs_base__image_config* c) {
static inline wuffs_base__rect_ie_u32 //
wuffs_base__image_config__bounds(wuffs_base__image_config* c) {
return c ? ((wuffs_base__rect_ie_u32){
.min_incl_x = 0,
.min_incl_y = 0,
@@ -1398,31 +1449,31 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds(
: ((wuffs_base__rect_ie_u32){});
}
static inline uint32_t wuffs_base__image_config__width(
wuffs_base__image_config* c) {
static inline uint32_t //
wuffs_base__image_config__width(wuffs_base__image_config* c) {
return c ? c->private_impl.width : 0;
}
static inline uint32_t wuffs_base__image_config__height(
wuffs_base__image_config* c) {
static inline uint32_t //
wuffs_base__image_config__height(wuffs_base__image_config* c) {
return c ? c->private_impl.height : 0;
}
static inline uint32_t wuffs_base__image_config__num_loops(
wuffs_base__image_config* c) {
static inline uint32_t //
wuffs_base__image_config__num_loops(wuffs_base__image_config* c) {
return c ? c->private_impl.num_loops : 0;
}
static inline uint32_t wuffs_base__image_config__first_frame_is_opaque(
wuffs_base__image_config* c) {
static inline uint32_t //
wuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {
return c ? c->private_impl.first_frame_is_opaque : false;
}
// TODO: this is the right API for planar (not packed) pixbufs? Should it allow
// decoding into a color model different from the format's intrinsic one? For
// example, decoding a JPEG image straight to RGBA instead of to YCbCr?
static inline size_t wuffs_base__image_config__pixbuf_size(
wuffs_base__image_config* c) {
static inline size_t //
wuffs_base__image_config__pixbuf_size(wuffs_base__image_config* c) {
if (c) {
uint64_t wh =
((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);
@@ -1434,55 +1485,64 @@ static inline size_t wuffs_base__image_config__pixbuf_size(
#ifdef __cplusplus
inline void wuffs_base__image_config::initialize(
wuffs_base__pixel_format pixfmt,
wuffs_base__pixel_subsampling pixsub,
uint32_t width,
uint32_t height,
uint32_t num_loops,
bool first_frame_is_opaque) {
inline void //
wuffs_base__image_config::initialize(wuffs_base__pixel_format pixfmt,
wuffs_base__pixel_subsampling pixsub,
uint32_t width,
uint32_t height,
uint32_t num_loops,
bool first_frame_is_opaque) {
wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height,
num_loops, first_frame_is_opaque);
}
inline void wuffs_base__image_config::invalidate() {
inline void //
wuffs_base__image_config::invalidate() {
wuffs_base__image_config__invalidate(this);
}
inline bool wuffs_base__image_config::is_valid() {
inline bool //
wuffs_base__image_config::is_valid() {
return wuffs_base__image_config__is_valid(this);
}
inline wuffs_base__pixel_format wuffs_base__image_config::pixel_format() {
inline wuffs_base__pixel_format //
wuffs_base__image_config::pixel_format() {
return wuffs_base__image_config__pixel_format(this);
}
inline wuffs_base__pixel_subsampling
inline wuffs_base__pixel_subsampling //
wuffs_base__image_config::pixel_subsampling() {
return wuffs_base__image_config__pixel_subsampling(this);
}
inline wuffs_base__rect_ie_u32 wuffs_base__image_config::bounds() {
inline wuffs_base__rect_ie_u32 //
wuffs_base__image_config::bounds() {
return wuffs_base__image_config__bounds(this);
}
inline uint32_t wuffs_base__image_config::width() {
inline uint32_t //
wuffs_base__image_config::width() {
return wuffs_base__image_config__width(this);
}
inline uint32_t wuffs_base__image_config::height() {
inline uint32_t //
wuffs_base__image_config::height() {
return wuffs_base__image_config__height(this);
}
inline uint32_t wuffs_base__image_config::num_loops() {
inline uint32_t //
wuffs_base__image_config::num_loops() {
return wuffs_base__image_config__num_loops(this);
}
inline uint32_t wuffs_base__image_config::first_frame_is_opaque() {
inline uint32_t //
wuffs_base__image_config::first_frame_is_opaque() {
return wuffs_base__image_config__first_frame_is_opaque(this);
}
inline size_t wuffs_base__image_config::pixbuf_size() {
inline size_t //
wuffs_base__image_config::pixbuf_size() {
return wuffs_base__image_config__pixbuf_size(this);
}
@@ -1548,10 +1608,10 @@ typedef struct {
} wuffs_base__image_buffer;
static inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf(
wuffs_base__image_buffer* b,
wuffs_base__image_config config,
wuffs_base__pixel_buffer pixbuf) {
static inline wuffs_base__status //
wuffs_base__image_buffer__set_from_pixbuf(wuffs_base__image_buffer* b,
wuffs_base__image_config config,
wuffs_base__pixel_buffer pixbuf) {
if (!b) {
return WUFFS_BASE__ERROR_BAD_RECEIVER;
}
@@ -1561,10 +1621,10 @@ static inline wuffs_base__status wuffs_base__image_buffer__set_from_pixbuf(
return WUFFS_BASE__STATUS_OK;
}
static inline wuffs_base__status wuffs_base__image_buffer__set_from_slice(
wuffs_base__image_buffer* b,
wuffs_base__image_config config,
wuffs_base__slice_u8 pixbuf_memory) {
static inline wuffs_base__status //
wuffs_base__image_buffer__set_from_slice(wuffs_base__image_buffer* b,
wuffs_base__image_config config,
wuffs_base__slice_u8 pixbuf_memory) {
if (!b) {
return WUFFS_BASE__ERROR_BAD_RECEIVER;
}
@@ -1585,13 +1645,13 @@ static inline wuffs_base__status wuffs_base__image_buffer__set_from_slice(
}
// The palette argument is ignored unless its length is exactly 1024.
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* b,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
bool blend,
wuffs_base__animation_disposal disposal,
wuffs_base__slice_u8 palette) {
static inline void //
wuffs_base__image_buffer__update(wuffs_base__image_buffer* b,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
bool blend,
wuffs_base__animation_disposal disposal,
wuffs_base__slice_u8 palette) {
if (!b) {
return;
}
@@ -1613,38 +1673,38 @@ static inline void wuffs_base__image_buffer__update(
}
// wuffs_base__image_config returns the overall configuration for this frame.
static inline wuffs_base__image_config* wuffs_base__image_buffer__image_config(
wuffs_base__image_buffer* b) {
static inline wuffs_base__image_config* //
wuffs_base__image_buffer__image_config(wuffs_base__image_buffer* b) {
return b ? &b->private_impl.config : NULL;
}
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__bounds(
wuffs_base__image_buffer* b) {
static inline wuffs_base__rect_ie_u32 //
wuffs_base__image_buffer__bounds(wuffs_base__image_buffer* b) {
return b ? wuffs_base__image_config__bounds(&b->private_impl.config)
: ((wuffs_base__rect_ie_u32){});
}
static inline uint32_t wuffs_base__image_buffer__width(
wuffs_base__image_buffer* b) {
static inline uint32_t //
wuffs_base__image_buffer__width(wuffs_base__image_buffer* b) {
return b ? wuffs_base__image_config__width(&b->private_impl.config) : 0;
}
static inline uint32_t wuffs_base__image_buffer__height(
wuffs_base__image_buffer* b) {
static inline uint32_t //
wuffs_base__image_buffer__height(wuffs_base__image_buffer* b) {
return b ? wuffs_base__image_config__height(&b->private_impl.config) : 0;
}
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* b) {
static inline wuffs_base__rect_ie_u32 //
wuffs_base__image_buffer__dirty_rect(wuffs_base__image_buffer* b) {
return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
// this frame. Zero means to display forever - a still (non-animated) image.
static inline wuffs_base__flicks wuffs_base__image_buffer__duration(
wuffs_base__image_buffer* b) {
static inline wuffs_base__flicks //
wuffs_base__image_buffer__duration(wuffs_base__image_buffer* b) {
return b ? b->private_impl.duration : 0;
}
@@ -1653,38 +1713,37 @@ static inline wuffs_base__flicks wuffs_base__image_buffer__duration(
//
// In Porter-Duff compositing operator terminology, false means "src" and true
// means "src over dst".
static inline bool wuffs_base__image_buffer__blend(
wuffs_base__image_buffer* b) {
static inline bool //
wuffs_base__image_buffer__blend(wuffs_base__image_buffer* b) {
return b && b->private_impl.blend;
}
// wuffs_base__image_buffer__disposal returns, for an animated image, how to
// dispose of this frame after displaying it.
static inline wuffs_base__animation_disposal wuffs_base__image_buffer__disposal(
wuffs_base__image_buffer* b) {
static inline wuffs_base__animation_disposal //
wuffs_base__image_buffer__disposal(wuffs_base__image_buffer* b) {
return b ? b->private_impl.disposal : 0;
}
// wuffs_base__image_buffer__palette_changed returns whether this frame's
// palette differs from the previous frame. It is conservative and may return
// false positives (but never false negatives).
static inline bool wuffs_base__image_buffer__palette_changed(
wuffs_base__image_buffer* b) {
static inline bool //
wuffs_base__image_buffer__palette_changed(wuffs_base__image_buffer* b) {
return b && b->private_impl.palette_changed;
}
// wuffs_base__image_buffer__palette returns the palette that the pixel data
// can index. The backing array is inside b and has length 1024.
static inline wuffs_base__slice_u8 wuffs_base__image_buffer__palette(
wuffs_base__image_buffer* b) {
static inline wuffs_base__slice_u8 //
wuffs_base__image_buffer__palette(wuffs_base__image_buffer* b) {
return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,
.len = 1024})
: ((wuffs_base__slice_u8){});
}
static inline wuffs_base__table_u8 wuffs_base__image_buffer__plane(
wuffs_base__image_buffer* b,
uint32_t p) {
static inline wuffs_base__table_u8 //
wuffs_base__image_buffer__plane(wuffs_base__image_buffer* b, uint32_t p) {
return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))
? b->private_impl.pixbuf.planes[p]
: ((wuffs_base__table_u8){});
@@ -1692,69 +1751,80 @@ static inline wuffs_base__table_u8 wuffs_base__image_buffer__plane(
#ifdef __cplusplus
inline wuffs_base__status wuffs_base__image_buffer::set_from_pixbuf(
wuffs_base__image_config config,
wuffs_base__pixel_buffer pixbuf) {
inline wuffs_base__status //
wuffs_base__image_buffer::set_from_pixbuf(wuffs_base__image_config config,
wuffs_base__pixel_buffer pixbuf) {
return wuffs_base__image_buffer__set_from_pixbuf(this, config, pixbuf);
}
inline wuffs_base__status wuffs_base__image_buffer::set_from_slice(
wuffs_base__image_config config,
wuffs_base__slice_u8 pixbuf_memory) {
inline wuffs_base__status //
wuffs_base__image_buffer::set_from_slice(wuffs_base__image_config config,
wuffs_base__slice_u8 pixbuf_memory) {
return wuffs_base__image_buffer__set_from_slice(this, config, pixbuf_memory);
}
inline void wuffs_base__image_buffer::update(
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
bool blend,
wuffs_base__animation_disposal disposal,
wuffs_base__slice_u8 palette) {
inline void //
wuffs_base__image_buffer::update(wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
bool blend,
wuffs_base__animation_disposal disposal,
wuffs_base__slice_u8 palette) {
wuffs_base__image_buffer__update(this, dirty_rect, duration, blend, disposal,
palette);
}
inline wuffs_base__image_config* wuffs_base__image_buffer::image_config() {
inline wuffs_base__image_config* //
wuffs_base__image_buffer::image_config() {
return wuffs_base__image_buffer__image_config(this);
}
inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::bounds() {
inline wuffs_base__rect_ie_u32 //
wuffs_base__image_buffer::bounds() {
return wuffs_base__image_buffer__bounds(this);
}
inline uint32_t wuffs_base__image_buffer::width() {
inline uint32_t //
wuffs_base__image_buffer::width() {
return wuffs_base__image_buffer__width(this);
}
inline uint32_t wuffs_base__image_buffer::height() {
inline uint32_t //
wuffs_base__image_buffer::height() {
return wuffs_base__image_buffer__height(this);
}
inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer::dirty_rect() {
inline wuffs_base__rect_ie_u32 //
wuffs_base__image_buffer::dirty_rect() {
return wuffs_base__image_buffer__dirty_rect(this);
}
inline wuffs_base__flicks wuffs_base__image_buffer::duration() {
inline wuffs_base__flicks //
wuffs_base__image_buffer::duration() {
return wuffs_base__image_buffer__duration(this);
}
inline bool wuffs_base__image_buffer::blend() {
inline bool //
wuffs_base__image_buffer::blend() {
return wuffs_base__image_buffer__blend(this);
}
inline wuffs_base__animation_disposal wuffs_base__image_buffer::disposal() {
inline wuffs_base__animation_disposal //
wuffs_base__image_buffer::disposal() {
return wuffs_base__image_buffer__disposal(this);
}
inline bool wuffs_base__image_buffer::palette_changed() {
inline bool //
wuffs_base__image_buffer::palette_changed() {
return wuffs_base__image_buffer__palette_changed(this);
}
inline wuffs_base__slice_u8 wuffs_base__image_buffer::palette() {
inline wuffs_base__slice_u8 //
wuffs_base__image_buffer::palette() {
return wuffs_base__image_buffer__palette(this);
}
inline wuffs_base__table_u8 wuffs_base__image_buffer::plane(uint32_t p) {
inline wuffs_base__table_u8 //
wuffs_base__image_buffer::plane(uint32_t p) {
return wuffs_base__image_buffer__plane(this, p);
}
@@ -2757,90 +2827,106 @@ extern "C" {
// inline attribute to guide optimizations such as inlining, to avoid the
// -Wunused-function warning, and we like to compile with -Wall -Werror.
static inline wuffs_base__empty_struct wuffs_base__return_empty_struct() {
static inline wuffs_base__empty_struct //
wuffs_base__return_empty_struct() {
return ((wuffs_base__empty_struct){});
}
// ---------------- Numeric Types
static inline uint8_t wuffs_base__load_u8be(uint8_t* p) {
static inline uint8_t //
wuffs_base__load_u8be(uint8_t* p) {
return p[0];
}
static inline uint16_t wuffs_base__load_u16be(uint8_t* p) {
static inline uint16_t //
wuffs_base__load_u16be(uint8_t* p) {
return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);
}
static inline uint16_t wuffs_base__load_u16le(uint8_t* p) {
static inline uint16_t //
wuffs_base__load_u16le(uint8_t* p) {
return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);
}
static inline uint32_t wuffs_base__load_u24be(uint8_t* p) {
static inline uint32_t //
wuffs_base__load_u24be(uint8_t* p) {
return ((uint32_t)(p[0]) << 16) | ((uint32_t)(p[1]) << 8) |
((uint32_t)(p[2]) << 0);
}
static inline uint32_t wuffs_base__load_u24le(uint8_t* p) {
static inline uint32_t //
wuffs_base__load_u24le(uint8_t* p) {
return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
((uint32_t)(p[2]) << 16);
}
static inline uint32_t wuffs_base__load_u32be(uint8_t* p) {
static inline uint32_t //
wuffs_base__load_u32be(uint8_t* p) {
return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |
((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);
}
static inline uint32_t wuffs_base__load_u32le(uint8_t* p) {
static inline uint32_t //
wuffs_base__load_u32le(uint8_t* p) {
return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |
((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);
}
static inline uint64_t wuffs_base__load_u40be(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u40be(uint8_t* p) {
return ((uint64_t)(p[0]) << 32) | ((uint64_t)(p[1]) << 24) |
((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 8) |
((uint64_t)(p[4]) << 0);
}
static inline uint64_t wuffs_base__load_u40le(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u40le(uint8_t* p) {
return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |
((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |
((uint64_t)(p[4]) << 32);
}
static inline uint64_t wuffs_base__load_u48be(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u48be(uint8_t* p) {
return ((uint64_t)(p[0]) << 40) | ((uint64_t)(p[1]) << 32) |
((uint64_t)(p[2]) << 24) | ((uint64_t)(p[3]) << 16) |
((uint64_t)(p[4]) << 8) | ((uint64_t)(p[5]) << 0);
}
static inline uint64_t wuffs_base__load_u48le(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u48le(uint8_t* p) {
return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |
((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |
((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40);
}
static inline uint64_t wuffs_base__load_u56be(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u56be(uint8_t* p) {
return ((uint64_t)(p[0]) << 48) | ((uint64_t)(p[1]) << 40) |
((uint64_t)(p[2]) << 32) | ((uint64_t)(p[3]) << 24) |
((uint64_t)(p[4]) << 16) | ((uint64_t)(p[5]) << 8) |
((uint64_t)(p[6]) << 0);
}
static inline uint64_t wuffs_base__load_u56le(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u56le(uint8_t* p) {
return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |
((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |
((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |
((uint64_t)(p[6]) << 48);
}
static inline uint64_t wuffs_base__load_u64be(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u64be(uint8_t* p) {
return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) |
((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) |
((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) |
((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0);
}
static inline uint64_t wuffs_base__load_u64le(uint8_t* p) {
static inline uint64_t //
wuffs_base__load_u64le(uint8_t* p) {
return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) |
((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) |
((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) |
@@ -2849,47 +2935,55 @@ static inline uint64_t wuffs_base__load_u64le(uint8_t* p) {
// --------
static inline void wuffs_base__store_u8be(uint8_t* p, uint8_t x) {
static inline void //
wuffs_base__store_u8be(uint8_t* p, uint8_t x) {
p[0] = x;
}
static inline void wuffs_base__store_u16be(uint8_t* p, uint16_t x) {
static inline void //
wuffs_base__store_u16be(uint8_t* p, uint16_t x) {
p[0] = x >> 8;
p[1] = x >> 0;
}
static inline void wuffs_base__store_u16le(uint8_t* p, uint16_t x) {
static inline void //
wuffs_base__store_u16le(uint8_t* p, uint16_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
}
static inline void wuffs_base__store_u24be(uint8_t* p, uint32_t x) {
static inline void //
wuffs_base__store_u24be(uint8_t* p, uint32_t x) {
p[0] = x >> 16;
p[1] = x >> 8;
p[2] = x >> 0;
}
static inline void wuffs_base__store_u24le(uint8_t* p, uint32_t x) {
static inline void //
wuffs_base__store_u24le(uint8_t* p, uint32_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
p[2] = x >> 16;
}
static inline void wuffs_base__store_u32be(uint8_t* p, uint32_t x) {
static inline void //
wuffs_base__store_u32be(uint8_t* p, uint32_t x) {
p[0] = x >> 24;
p[1] = x >> 16;
p[2] = x >> 8;
p[3] = x >> 0;
}
static inline void wuffs_base__store_u32le(uint8_t* p, uint32_t x) {
static inline void //
wuffs_base__store_u32le(uint8_t* p, uint32_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
p[2] = x >> 16;
p[3] = x >> 24;
}
static inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u40be(uint8_t* p, uint64_t x) {
p[0] = x >> 32;
p[1] = x >> 24;
p[2] = x >> 16;
@@ -2897,7 +2991,8 @@ static inline void wuffs_base__store_u40be(uint8_t* p, uint64_t x) {
p[4] = x >> 0;
}
static inline void wuffs_base__store_u40le(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u40le(uint8_t* p, uint64_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
p[2] = x >> 16;
@@ -2905,7 +3000,8 @@ static inline void wuffs_base__store_u40le(uint8_t* p, uint64_t x) {
p[4] = x >> 32;
}
static inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u48be(uint8_t* p, uint64_t x) {
p[0] = x >> 40;
p[1] = x >> 32;
p[2] = x >> 24;
@@ -2914,7 +3010,8 @@ static inline void wuffs_base__store_u48be(uint8_t* p, uint64_t x) {
p[5] = x >> 0;
}
static inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u48le(uint8_t* p, uint64_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
p[2] = x >> 16;
@@ -2923,7 +3020,8 @@ static inline void wuffs_base__store_u48le(uint8_t* p, uint64_t x) {
p[5] = x >> 40;
}
static inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u56be(uint8_t* p, uint64_t x) {
p[0] = x >> 48;
p[1] = x >> 40;
p[2] = x >> 32;
@@ -2933,7 +3031,8 @@ static inline void wuffs_base__store_u56be(uint8_t* p, uint64_t x) {
p[6] = x >> 0;
}
static inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u56le(uint8_t* p, uint64_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
p[2] = x >> 16;
@@ -2943,7 +3042,8 @@ static inline void wuffs_base__store_u56le(uint8_t* p, uint64_t x) {
p[6] = x >> 48;
}
static inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u64be(uint8_t* p, uint64_t x) {
p[0] = x >> 56;
p[1] = x >> 48;
p[2] = x >> 40;
@@ -2954,7 +3054,8 @@ static inline void wuffs_base__store_u64be(uint8_t* p, uint64_t x) {
p[7] = x >> 0;
}
static inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) {
static inline void //
wuffs_base__store_u64le(uint8_t* p, uint64_t x) {
p[0] = x >> 0;
p[1] = x >> 8;
p[2] = x >> 16;
@@ -2967,43 +3068,50 @@ static inline void wuffs_base__store_u64le(uint8_t* p, uint64_t x) {
// --------
static inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {
static inline void //
wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) {
*x = wuffs_base__u8__sat_add(*x, y);
}
static inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {
static inline void //
wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) {
*x = wuffs_base__u8__sat_sub(*x, y);
}
static inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {
static inline void //
wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) {
*x = wuffs_base__u16__sat_add(*x, y);
}
static inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {
static inline void //
wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) {
*x = wuffs_base__u16__sat_sub(*x, y);
}
static inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {
static inline void //
wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) {
*x = wuffs_base__u32__sat_add(*x, y);
}
static inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {
static inline void //
wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) {
*x = wuffs_base__u32__sat_sub(*x, y);
}
static inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {
static inline void //
wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) {
*x = wuffs_base__u64__sat_add(*x, y);
}
static inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {
static inline void //
wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) {
*x = wuffs_base__u64__sat_sub(*x, y);
}
// ---------------- Slices and Tables
static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(
wuffs_base__slice_u8 s,
uint64_t i) {
static inline wuffs_base__slice_u8 //
wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {
if ((i <= SIZE_MAX) && (i <= s.len)) {
return ((wuffs_base__slice_u8){
.ptr = s.ptr + i,
@@ -3013,19 +3121,18 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(
return ((wuffs_base__slice_u8){});
}
static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(
wuffs_base__slice_u8 s,
uint64_t j) {
static inline wuffs_base__slice_u8 //
wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {
if ((j <= SIZE_MAX) && (j <= s.len)) {
return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});
}
return ((wuffs_base__slice_u8){});
}
static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(
wuffs_base__slice_u8 s,
uint64_t i,
uint64_t j) {
static inline wuffs_base__slice_u8 //
wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
uint64_t i,
uint64_t j) {
if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {
return ((wuffs_base__slice_u8){
.ptr = s.ptr + i,
@@ -3036,9 +3143,8 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(
}
// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.
static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(
wuffs_base__slice_u8 s,
uint64_t up_to) {
static inline wuffs_base__slice_u8 //
wuffs_base__slice_u8__prefix(wuffs_base__slice_u8 s, uint64_t up_to) {
if ((uint64_t)(s.len) > up_to) {
s.len = up_to;
}
@@ -3046,9 +3152,8 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(
}
// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.
static inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix(
wuffs_base__slice_u8 s,
uint64_t up_to) {
static inline wuffs_base__slice_u8 //
wuffs_base__slice_u8__suffix(wuffs_base__slice_u8 s, uint64_t up_to) {
if ((uint64_t)(s.len) > up_to) {
s.ptr += (uint64_t)(s.len) - up_to;
s.len = up_to;
@@ -3061,9 +3166,9 @@ static inline wuffs_base__slice_u8 wuffs_base__slice_u8__suffix(
//
// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty
// slice) is valid and results in a no-op.
static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
wuffs_base__slice_u8 dst,
wuffs_base__slice_u8 src) {
static inline uint64_t //
wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
wuffs_base__slice_u8 src) {
size_t length = dst.len < src.len ? dst.len : src.len;
if (length > 0) {
memmove(dst.ptr, src.ptr, length);
@@ -3073,9 +3178,8 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
// --------
static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
wuffs_base__table_u8 t,
uint32_t y) {
static inline wuffs_base__slice_u8 //
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
if (y < t.height) {
return ((wuffs_base__slice_u8){
.ptr = t.ptr + (t.stride * y),
@@ -3087,52 +3191,52 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
// ---------------- Utility
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_incl,
uint32_t max_incl) {
static inline wuffs_base__range_ii_u32 //
wuffs_base__utility__make_range_ii_u32(wuffs_base__utility* ignored,
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_incl = min_incl,
.max_incl = max_incl,
});
}
static inline wuffs_base__range_ie_u32 wuffs_base__utility__make_range_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_incl,
uint32_t max_excl) {
static inline wuffs_base__range_ie_u32 //
wuffs_base__utility__make_range_ie_u32(wuffs_base__utility* ignored,
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_incl = min_incl,
.max_excl = max_excl,
});
}
static inline wuffs_base__range_ii_u64 wuffs_base__utility__make_range_ii_u64(
wuffs_base__utility* ignored,
uint64_t min_incl,
uint64_t max_incl) {
static inline wuffs_base__range_ii_u64 //
wuffs_base__utility__make_range_ii_u64(wuffs_base__utility* ignored,
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_incl = min_incl,
.max_incl = max_incl,
});
}
static inline wuffs_base__range_ie_u64 wuffs_base__utility__make_range_ie_u64(
wuffs_base__utility* ignored,
uint64_t min_incl,
uint64_t max_excl) {
static inline wuffs_base__range_ie_u64 //
wuffs_base__utility__make_range_ie_u64(wuffs_base__utility* ignored,
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_incl = min_incl,
.max_excl = max_excl,
});
}
static inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_incl_x,
uint32_t min_incl_y,
uint32_t max_incl_x,
uint32_t max_incl_y) {
static inline wuffs_base__rect_ii_u32 //
wuffs_base__utility__make_rect_ii_u32(wuffs_base__utility* ignored,
uint32_t min_incl_x,
uint32_t min_incl_y,
uint32_t max_incl_x,
uint32_t max_incl_y) {
return ((wuffs_base__rect_ii_u32){
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
@@ -3141,12 +3245,12 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32(
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_incl_x,
uint32_t min_incl_y,
uint32_t max_excl_x,
uint32_t max_excl_y) {
static inline wuffs_base__rect_ie_u32 //
wuffs_base__utility__make_rect_ie_u32(wuffs_base__utility* ignored,
uint32_t min_incl_x,
uint32_t min_incl_y,
uint32_t max_excl_x,
uint32_t max_excl_y) {
return ((wuffs_base__rect_ie_u32){
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
@@ -3157,17 +3261,20 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
// ---------------- I/O
static inline bool wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {
static inline bool //
wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {
return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) &&
(buf.wi >= buf.ri);
}
static inline bool wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {
static inline bool //
wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {
wuffs_base__io_buffer* buf = o.private_impl.buf;
return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.bounds[1]);
}
static inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {
static inline bool //
wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {
wuffs_base__io_buffer* buf = o.private_impl.buf;
// Note: if making this function public (i.e. moving it to base-header.h), it
// also needs to allow NULL (i.e. implicit, callee-calculated) bounds.
@@ -3178,7 +3285,8 @@ static inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {
(o.private_impl.bounds[1] == NULL));
}
static inline bool wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {
static inline bool //
wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {
wuffs_base__io_buffer* buf = o.private_impl.buf;
// Note: if making this function public (i.e. moving it to base-header.h), it
// also needs to allow NULL (i.e. implicit, callee-calculated) bounds.
@@ -3189,12 +3297,12 @@ static inline bool wuffs_base__io_writer__is_valid(wuffs_base__io_writer o) {
(o.private_impl.bounds[1] == NULL));
}
static inline uint32_t wuffs_base__io_writer__copy_n_from_history(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
uint32_t length,
uint32_t distance) {
static inline uint32_t //
wuffs_base__io_writer__copy_n_from_history(uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
uint32_t length,
uint32_t distance) {
if (!distance) {
return 0;
}
@@ -3237,12 +3345,12 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_history(
// - distance > 0
// - distance <= (*ptr_ptr - start)
// - length <= (end - *ptr_ptr)
static inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
uint32_t length,
uint32_t distance) {
static inline uint32_t //
wuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
uint32_t length,
uint32_t distance) {
uint8_t* ptr = *ptr_ptr;
start = ptr - distance;
uint32_t n = length;
@@ -3258,12 +3366,12 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_history_fast(
return length;
}
static inline uint32_t wuffs_base__io_writer__copy_n_from_reader(
uint8_t** ptr_ioptr_w,
uint8_t* iobounds1_w,
uint32_t length,
uint8_t** ptr_ioptr_r,
uint8_t* iobounds1_r) {
static inline uint32_t //
wuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w,
uint8_t* iobounds1_w,
uint32_t length,
uint8_t** ptr_ioptr_r,
uint8_t* iobounds1_r) {
uint8_t* ioptr_w = *ptr_ioptr_w;
size_t n = length;
if (n > ((size_t)(iobounds1_w - ioptr_w))) {
@@ -3281,10 +3389,10 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_reader(
return n;
}
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_ioptr_w,
uint8_t* iobounds1_w,
wuffs_base__slice_u8 src) {
static inline uint64_t //
wuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w,
uint8_t* iobounds1_w,
wuffs_base__slice_u8 src) {
uint8_t* ioptr_w = *ptr_ioptr_w;
size_t n = src.len;
if (n > ((size_t)(iobounds1_w - ioptr_w))) {
@@ -3297,11 +3405,11 @@ static inline uint64_t wuffs_base__io_writer__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__io_writer__copy_n_from_slice(
uint8_t** ptr_ioptr_w,
uint8_t* iobounds1_w,
uint32_t length,
wuffs_base__slice_u8 src) {
static inline uint32_t //
wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w,
uint8_t* iobounds1_w,
uint32_t length,
wuffs_base__slice_u8 src) {
uint8_t* ioptr_w = *ptr_ioptr_w;
size_t n = src.len;
if (n > length) {
@@ -3317,29 +3425,28 @@ static inline uint32_t wuffs_base__io_writer__copy_n_from_slice(
return n;
}
static inline wuffs_base__empty_struct wuffs_base__io_reader__set_limit(
wuffs_base__io_reader* o,
uint8_t* ioptr_r,
uint64_t limit) {
static inline wuffs_base__empty_struct //
wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,
uint8_t* ioptr_r,
uint64_t limit) {
if (o && (((size_t)(o->private_impl.bounds[1] - ioptr_r)) > limit)) {
o->private_impl.bounds[1] = ioptr_r + limit;
}
return ((wuffs_base__empty_struct){});
}
static inline wuffs_base__empty_struct wuffs_base__io_reader__set_mark(
wuffs_base__io_reader* o,
uint8_t* mark) {
static inline wuffs_base__empty_struct //
wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {
o->private_impl.bounds[0] = mark;
return ((wuffs_base__empty_struct){});
}
static inline wuffs_base__empty_struct wuffs_base__io_writer__set(
wuffs_base__io_writer* o,
wuffs_base__io_buffer* b,
uint8_t** ioptr1_ptr,
uint8_t** ioptr2_ptr,
wuffs_base__slice_u8 s) {
static inline wuffs_base__empty_struct //
wuffs_base__io_writer__set(wuffs_base__io_writer* o,
wuffs_base__io_buffer* b,
uint8_t** ioptr1_ptr,
uint8_t** ioptr2_ptr,
wuffs_base__slice_u8 s) {
b->ptr = s.ptr;
b->len = s.len;
b->wi = 0;
@@ -3353,9 +3460,8 @@ static inline wuffs_base__empty_struct wuffs_base__io_writer__set(
return ((wuffs_base__empty_struct){});
}
static inline wuffs_base__empty_struct wuffs_base__io_writer__set_mark(
wuffs_base__io_writer* o,
uint8_t* mark) {
static inline wuffs_base__empty_struct //
wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {
o->private_impl.bounds[0] = mark;
return ((wuffs_base__empty_struct){});
}
@@ -3424,7 +3530,8 @@ static const uint16_t wuffs_base__status__string_offsets[] = {
0x00B9, 0x00D9, 0x00E6, 0x00FA,
};
const char* wuffs_base__status__string(wuffs_base__status s) {
const char* //
wuffs_base__status__string(wuffs_base__status s) {
uint16_t o = wuffs_base__status__string_offsets[(uint8_t)(s >> 24)];
return o ? wuffs_base__status__string_data + o : "unknown status";
}