Rename inclusive and exclusive to incl and excl

This commit is contained in:
Nigel Tao committed 2018-06-11 09:04:12 +10:00
1 parent 3d035df908
commit c5b7b7097e
23 files changed
+1649 -2071

No files matched your search

+32 -32
View File
@@ -287,69 +287,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+84 -110
View File
@@ -285,20 +285,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -306,14 +305,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -326,28 +325,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -355,14 +353,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -375,33 +373,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -409,14 +406,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -429,28 +426,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -458,14 +454,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -478,14 +474,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -493,31 +489,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -525,21 +518,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -552,14 +541,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -568,7 +553,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -576,24 +561,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -601,21 +583,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -628,25 +606,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1027,10 +1001,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1149,10 +1123,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+23 -25
View File
@@ -36,27 +36,26 @@ const basePublicH = "" +
"LE(uint64_t) wuffs_base__table_u64;\n\n" +
"" +
"// ---------------- Ranges and Rects\n\n// Ranges are either inclusive (\"range_ii\") or exclusive (\"range_ie\") on the\n// high end. Both the \"ii\" and \"ie\" flavors are useful in practice.\n//\n// The \"ei\" and \"ee\" flavors also exist in theory, but aren't widely used. In\n// Wuffs, the low end is always inclusive.\n//\n// The \"ii\" (closed interval) flavor is useful when refining e.g. \"the set of\n// all uint32_t values\" to a contiguous subset: \"uint32_t values in the closed\n// interval [M, N]\", for uint32_t values M and N. An unrefined type (in other\n// words, the set of all uint32_t values) is not representable in the \"ie\"\n// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.\n//\n// On the other hand, the \"ie\" (half-open interval) flavor is recommended by\n// Dijkstra's \"Why numbering should start at zero\" at\n// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further\n// discussion of motivating rationale is at\n// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-close" +
"d-inclusive\n//\n// For example, with \"ie\", the number of elements in \"uint32_t values in the\n// half-open interval [M, N)\" is equal to max(0, N-M). Furthermore, that number\n// of elements (in one dimension, a length, in two dimensions, a width or\n// height) is itself representable as a uint32_t without overflow, again for\n// uint32_t values M and N. In the contrasting \"ii\" flavor, the length of the\n// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a\n// uint32_t. In Wuffs, because of this potential overflow, the \"ie\" flavor has\n// length / width / height methods, but the \"ii\" flavor does not.\n//\n// It is valid for min > max (for range_ii) or for min >= max (for range_ie),\n// in which case the range is empty. There are multiple representations of an\n// empty range.\n\ntypedef struct {\n uint32_t min_inclusive;\n uint32_t max_inclusive;\n} wuffs_base__range_ii_u32;\n\nstatic inline bool wuffs_base__range_ii_u32__is_empty(\n wuffs_base__range_ii_u32 r) {\n return r.min_inclusive > r.max_inc" +
"lusive;\n}\n\nstatic inline bool wuffs_base__range_ii_u32__equals(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n return (r.min_inclusive == s.min_inclusive &&\n r.max_inclusive == s.max_inclusive) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ii_u32__contains(\n wuffs_base__range_ii_u32 r,\n uint32_t x) {\n return (r.min_inclusive <= x) && (x <= r.max_inclusive);\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);\n r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);\n return r;\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs" +
"_base__range_ii_u32__is_empty(s)) {\n return r;\n }\n r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);\n r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);\n return r;\n}\n\n" +
"d-inclusive\n//\n// For example, with \"ie\", the number of elements in \"uint32_t values in the\n// half-open interval [M, N)\" is equal to max(0, N-M). Furthermore, that number\n// of elements (in one dimension, a length, in two dimensions, a width or\n// height) is itself representable as a uint32_t without overflow, again for\n// uint32_t values M and N. In the contrasting \"ii\" flavor, the length of the\n// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a\n// uint32_t. In Wuffs, because of this potential overflow, the \"ie\" flavor has\n// length / width / height methods, but the \"ii\" flavor does not.\n//\n// It is valid for min > max (for range_ii) or for min >= max (for range_ie),\n// in which case the range is empty. There are multiple representations of an\n// empty range.\n\ntypedef struct {\n uint32_t min_incl;\n uint32_t max_incl;\n} wuffs_base__range_ii_u32;\n\nstatic inline bool wuffs_base__range_ii_u32__is_empty(\n wuffs_base__range_ii_u32 r) {\n return r.min_incl > r.max_incl;\n}\n\nstatic in" +
"line bool wuffs_base__range_ii_u32__equals(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n return (r.min_incl == s.min_incl && r.max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u32__is_empty(r) &&\n wuffs_base__range_ii_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ii_u32__contains(\n wuffs_base__range_ii_u32 r,\n uint32_t x) {\n return (r.min_incl <= x) && (x <= r.max_incl);\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);\n r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);\n return r;\n}\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(\n wuffs_base__range_ii_u32 r,\n wuffs_base__range_ii_u32 s) {\n if (wuffs_base__range_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u32__is_empty(s)) {\n return r;\n }\n r.min_incl = wuffs_base__u32__min(" +
"r.min_incl, s.min_incl);\n r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);\n return r;\n}\n\n" +
"" +
"// --------\n\ntypedef struct {\n uint32_t min_inclusive;\n uint32_t max_exclusive;\n} wuffs_base__range_ie_u32;\n\nstatic inline bool wuffs_base__range_ie_u32__is_empty(\n wuffs_base__range_ie_u32 r) {\n return r.min_inclusive >= r.max_exclusive;\n}\n\nstatic inline bool wuffs_base__range_ie_u32__equals(\n wuffs_base__range_ie_u32 r,\n wuffs_base__range_ie_u32 s) {\n return (r.min_inclusive == s.min_inclusive &&\n r.max_exclusive == s.max_exclusive) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ie_u32__contains(\n wuffs_base__range_ie_u32 r,\n uint32_t x) {\n return (r.min_inclusive <= x) && (x < r.max_exclusive);\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(\n wuffs_base__range_ie_u32 r,\n wuffs_base__range_ie_u32 s) {\n r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);\n r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclu" +
"sive);\n return r;\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(\n wuffs_base__range_ie_u32 r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u32__is_empty(s)) {\n return r;\n }\n r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);\n r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);\n return r;\n}\n\nstatic inline uint32_t wuffs_base__range_ie_u32__length(\n wuffs_base__range_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive, r.min_inclusive);\n}\n\n" +
"// --------\n\ntypedef struct {\n uint32_t min_incl;\n uint32_t max_excl;\n} wuffs_base__range_ie_u32;\n\nstatic inline bool wuffs_base__range_ie_u32__is_empty(\n wuffs_base__range_ie_u32 r) {\n return r.min_incl >= r.max_excl;\n}\n\nstatic inline bool wuffs_base__range_ie_u32__equals(\n wuffs_base__range_ie_u32 r,\n wuffs_base__range_ie_u32 s) {\n return (r.min_incl == s.min_incl && r.max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u32__is_empty(r) &&\n wuffs_base__range_ie_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ie_u32__contains(\n wuffs_base__range_ie_u32 r,\n uint32_t x) {\n return (r.min_incl <= x) && (x < r.max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(\n wuffs_base__range_ie_u32 r,\n wuffs_base__range_ie_u32 s) {\n r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);\n r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);\n return r;\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__uni" +
"on(\n wuffs_base__range_ie_u32 r,\n wuffs_base__range_ie_u32 s) {\n if (wuffs_base__range_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u32__is_empty(s)) {\n return r;\n }\n r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);\n r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);\n return r;\n}\n\nstatic inline uint32_t wuffs_base__range_ie_u32__length(\n wuffs_base__range_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);\n}\n\n" +
"" +
"// --------\n\ntypedef struct {\n uint64_t min_inclusive;\n uint64_t max_inclusive;\n} wuffs_base__range_ii_u64;\n\nstatic inline bool wuffs_base__range_ii_u64__is_empty(\n wuffs_base__range_ii_u64 r) {\n return r.min_inclusive > r.max_inclusive;\n}\n\nstatic inline bool wuffs_base__range_ii_u64__equals(\n wuffs_base__range_ii_u64 r,\n wuffs_base__range_ii_u64 s) {\n return (r.min_inclusive == s.min_inclusive &&\n r.max_inclusive == s.max_inclusive) ||\n (wuffs_base__range_ii_u64__is_empty(r) &&\n wuffs_base__range_ii_u64__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ii_u64__contains(\n wuffs_base__range_ii_u64 r,\n uint64_t x) {\n return (r.min_inclusive <= x) && (x <= r.max_inclusive);\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(\n wuffs_base__range_ii_u64 r,\n wuffs_base__range_ii_u64 s) {\n r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);\n r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclu" +
"sive);\n return r;\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(\n wuffs_base__range_ii_u64 r,\n wuffs_base__range_ii_u64 s) {\n if (wuffs_base__range_ii_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u64__is_empty(s)) {\n return r;\n }\n r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);\n r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);\n return r;\n}\n\n" +
"// --------\n\ntypedef struct {\n uint64_t min_incl;\n uint64_t max_incl;\n} wuffs_base__range_ii_u64;\n\nstatic inline bool wuffs_base__range_ii_u64__is_empty(\n wuffs_base__range_ii_u64 r) {\n return r.min_incl > r.max_incl;\n}\n\nstatic inline bool wuffs_base__range_ii_u64__equals(\n wuffs_base__range_ii_u64 r,\n wuffs_base__range_ii_u64 s) {\n return (r.min_incl == s.min_incl && r.max_incl == s.max_incl) ||\n (wuffs_base__range_ii_u64__is_empty(r) &&\n wuffs_base__range_ii_u64__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ii_u64__contains(\n wuffs_base__range_ii_u64 r,\n uint64_t x) {\n return (r.min_incl <= x) && (x <= r.max_incl);\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(\n wuffs_base__range_ii_u64 r,\n wuffs_base__range_ii_u64 s) {\n r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);\n r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);\n return r;\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__uni" +
"on(\n wuffs_base__range_ii_u64 r,\n wuffs_base__range_ii_u64 s) {\n if (wuffs_base__range_ii_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ii_u64__is_empty(s)) {\n return r;\n }\n r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);\n r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);\n return r;\n}\n\n" +
"" +
"// --------\n\ntypedef struct {\n uint64_t min_inclusive;\n uint64_t max_exclusive;\n} wuffs_base__range_ie_u64;\n\nstatic inline bool wuffs_base__range_ie_u64__is_empty(\n wuffs_base__range_ie_u64 r) {\n return r.min_inclusive >= r.max_exclusive;\n}\n\nstatic inline bool wuffs_base__range_ie_u64__equals(\n wuffs_base__range_ie_u64 r,\n wuffs_base__range_ie_u64 s) {\n return (r.min_inclusive == s.min_inclusive &&\n r.max_exclusive == s.max_exclusive) ||\n (wuffs_base__range_ie_u64__is_empty(r) &&\n wuffs_base__range_ie_u64__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ie_u64__contains(\n wuffs_base__range_ie_u64 r,\n uint64_t x) {\n return (r.min_inclusive <= x) && (x < r.max_exclusive);\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(\n wuffs_base__range_ie_u64 r,\n wuffs_base__range_ie_u64 s) {\n r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);\n r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclu" +
"sive);\n return r;\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(\n wuffs_base__range_ie_u64 r,\n wuffs_base__range_ie_u64 s) {\n if (wuffs_base__range_ie_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u64__is_empty(s)) {\n return r;\n }\n r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);\n r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);\n return r;\n}\n\nstatic inline uint64_t wuffs_base__range_ie_u64__length(\n wuffs_base__range_ie_u64 r) {\n return wuffs_base__u64__sat_sub(r.max_exclusive, r.min_inclusive);\n}\n\n" +
"// --------\n\ntypedef struct {\n uint64_t min_incl;\n uint64_t max_excl;\n} wuffs_base__range_ie_u64;\n\nstatic inline bool wuffs_base__range_ie_u64__is_empty(\n wuffs_base__range_ie_u64 r) {\n return r.min_incl >= r.max_excl;\n}\n\nstatic inline bool wuffs_base__range_ie_u64__equals(\n wuffs_base__range_ie_u64 r,\n wuffs_base__range_ie_u64 s) {\n return (r.min_incl == s.min_incl && r.max_excl == s.max_excl) ||\n (wuffs_base__range_ie_u64__is_empty(r) &&\n wuffs_base__range_ie_u64__is_empty(s));\n}\n\nstatic inline bool wuffs_base__range_ie_u64__contains(\n wuffs_base__range_ie_u64 r,\n uint64_t x) {\n return (r.min_incl <= x) && (x < r.max_excl);\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(\n wuffs_base__range_ie_u64 r,\n wuffs_base__range_ie_u64 s) {\n r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);\n r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);\n return r;\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__uni" +
"on(\n wuffs_base__range_ie_u64 r,\n wuffs_base__range_ie_u64 s) {\n if (wuffs_base__range_ie_u64__is_empty(r)) {\n return s;\n }\n if (wuffs_base__range_ie_u64__is_empty(s)) {\n return r;\n }\n r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);\n r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);\n return r;\n}\n\nstatic inline uint64_t wuffs_base__range_ie_u64__length(\n wuffs_base__range_ie_u64 r) {\n return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the\n// integer grid. The \"ii\" means that the bounds are inclusive on the low end\n// and inclusive on the high end. It contains all points (x, y) such that\n// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.\n//\n// It is valid for min > max, in which case the rectangle is empty. There are\n// multiple representations of an empty rectangle.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_inclusive_x;\n uint32_t min_inclusive_y;\n uint32_t max_inclusive_x;\n uint32_t max_inclusive_y;\n} wuffs_base__rect_ii_u32;\n\nstatic inline bool wuffs_base__rect_ii_u32__is_empty(\n wuffs_base__rect_ii_u32 r) {\n return (r.min_inclusive_x > r.max_inclusive_x) ||\n (r.min_inclusive_y > r.max_inclusive_y);\n}\n\nstatic inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,\n wuffs_base__rect_ii_u32 s) {\n return (r.min_inclusive_" +
"x == s.min_inclusive_x &&\n r.min_inclusive_y == s.min_inclusive_y &&\n r.max_inclusive_x == s.max_inclusive_x &&\n r.max_inclusive_y == s.max_inclusive_y) ||\n (wuffs_base__rect_ii_u32__is_empty(r) &&\n wuffs_base__rect_ii_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,\n uint32_t x,\n uint32_t y) {\n return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&\n (r.min_inclusive_y <= y) && (y <= r.max_inclusive_y);\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersection(\n wuffs_base__rect_ii_u32 r,\n wuffs_base__rect_ii_u32 s) {\n r.min_inclusive_x =\n wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);\n r.min_inclusive_y =\n wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);\n r.max_inclusive_x =\n wuffs_base__u32__min(r.max_inclusive_x, s.max_inclu" +
"sive_x);\n r.max_inclusive_y =\n wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);\n return r;\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(\n wuffs_base__rect_ii_u32 r,\n wuffs_base__rect_ii_u32 s) {\n if (wuffs_base__rect_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ii_u32__is_empty(s)) {\n return r;\n }\n r.min_inclusive_x =\n wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);\n r.min_inclusive_y =\n wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);\n r.max_inclusive_x =\n wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);\n r.max_inclusive_y =\n wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);\n return r;\n}\n\n" +
"// --------\n\n// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the\n// integer grid. The \"ii\" means that the bounds are inclusive on the low end\n// and inclusive on the high end. It contains all points (x, y) such that\n// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.\n//\n// It is valid for min > max, in which case the rectangle is empty. There are\n// multiple representations of an empty rectangle.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_incl_x;\n uint32_t max_incl_y;\n} wuffs_base__rect_ii_u32;\n\nstatic inline bool wuffs_base__rect_ii_u32__is_empty(\n wuffs_base__rect_ii_u32 r) {\n return (r.min_incl_x > r.max_incl_x) || (r.min_incl_y > r.max_incl_y);\n}\n\nstatic inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,\n wuffs_base__rect_ii_u32 s) {\n return (r.min_incl_x == s.min_incl_x && r.min_incl_y == s.min_incl_y &&\n r" +
".max_incl_x == s.max_incl_x && r.max_incl_y == s.max_incl_y) ||\n (wuffs_base__rect_ii_u32__is_empty(r) &&\n wuffs_base__rect_ii_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,\n uint32_t x,\n uint32_t y) {\n return (r.min_incl_x <= x) && (x <= r.max_incl_x) && (r.min_incl_y <= y) &&\n (y <= r.max_incl_y);\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersection(\n wuffs_base__rect_ii_u32 r,\n wuffs_base__rect_ii_u32 s) {\n r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);\n r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);\n r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);\n r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);\n return r;\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(\n wuffs_base__rect_ii_u32 r,\n wuffs_" +
"base__rect_ii_u32 s) {\n if (wuffs_base__rect_ii_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ii_u32__is_empty(s)) {\n return r;\n }\n r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);\n r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);\n r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);\n r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);\n return r;\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the\n// integer grid. The \"ie\" means that the bounds are inclusive on the low end\n// and exclusive on the high end. It contains all points (x, y) such that\n// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.\n//\n// It is valid for min >= max, in which case the rectangle is empty. There are\n// multiple representations of an empty rectangle, including a value with all\n// fields zero.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_inclusive_x;\n uint32_t min_inclusive_y;\n uint32_t max_exclusive_x;\n uint32_t max_exclusive_y;\n} wuffs_base__rect_ie_u32;\n\nstatic inline bool wuffs_base__rect_ie_u32__is_empty(\n wuffs_base__rect_ie_u32 r) {\n return (r.min_inclusive_x >= r.max_exclusive_x) ||\n (r.min_inclusive_y >= r.max_exclusive_y);\n}\n\nstatic inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,\n wuffs_base" +
"__rect_ie_u32 s) {\n return (r.min_inclusive_x == s.min_inclusive_x &&\n r.min_inclusive_y == s.min_inclusive_y &&\n r.max_exclusive_x == s.max_exclusive_x &&\n r.max_exclusive_y == s.max_exclusive_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,\n uint32_t x,\n uint32_t y) {\n return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&\n (r.min_inclusive_y <= y) && (y < r.max_exclusive_y);\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersection(\n wuffs_base__rect_ie_u32 r,\n wuffs_base__rect_ie_u32 s) {\n r.min_inclusive_x =\n wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);\n r.min_inclusive_y =\n wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);\n r.max_exclusive_x =\n wuffs_ba" +
"se__u32__min(r.max_exclusive_x, s.max_exclusive_x);\n r.max_exclusive_y =\n wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);\n return r;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(\n wuffs_base__rect_ie_u32 r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(s)) {\n return r;\n }\n r.min_inclusive_x =\n wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);\n r.min_inclusive_y =\n wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);\n r.max_exclusive_x =\n wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);\n r.max_exclusive_y =\n wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);\n return r;\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__width(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive_x, r.min_inclusive_x);\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__height(\n wuffs_base__rect" +
"_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);\n}\n\n" +
"// --------\n\n// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the\n// integer grid. The \"ie\" means that the bounds are inclusive on the low end\n// and exclusive on the high end. It contains all points (x, y) such that\n// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.\n//\n// It is valid for min >= max, in which case the rectangle is empty. There are\n// multiple representations of an empty rectangle, including a value with all\n// fields zero.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_incl_x;\n uint32_t min_incl_y;\n uint32_t max_excl_x;\n uint32_t max_excl_y;\n} wuffs_base__rect_ie_u32;\n\nstatic inline bool wuffs_base__rect_ie_u32__is_empty(\n wuffs_base__rect_ie_u32 r) {\n return (r.min_incl_x >= r.max_excl_x) || (r.min_incl_y >= r.max_excl_y);\n}\n\nstatic inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,\n wuffs_base__rect_ie_u32 s) {\n return (r.min_incl_x == s.min_incl_x &" +
"& r.min_incl_y == s.min_incl_y &&\n r.max_excl_x == s.max_excl_x && r.max_excl_y == s.max_excl_y) ||\n (wuffs_base__rect_ie_u32__is_empty(r) &&\n wuffs_base__rect_ie_u32__is_empty(s));\n}\n\nstatic inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,\n uint32_t x,\n uint32_t y) {\n return (r.min_incl_x <= x) && (x < r.max_excl_x) && (r.min_incl_y <= y) &&\n (y < r.max_excl_y);\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersection(\n wuffs_base__rect_ie_u32 r,\n wuffs_base__rect_ie_u32 s) {\n r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);\n r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);\n r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);\n r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);\n return r;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union" +
"(\n wuffs_base__rect_ie_u32 r,\n wuffs_base__rect_ie_u32 s) {\n if (wuffs_base__rect_ie_u32__is_empty(r)) {\n return s;\n }\n if (wuffs_base__rect_ie_u32__is_empty(s)) {\n return r;\n }\n r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);\n r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);\n r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);\n r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);\n return r;\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__width(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_excl_x, r.min_incl_x);\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__height(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);\n}\n\n" +
"" +
"// ---------------- I/O\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer;\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_buffer* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* bounds[2];\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/A" +
"BI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_buffer* buf;\n // The bounds values are typically NULL, when created by the Wuffs public\n // API. NULL means that the callee substitutes the implicit bounds derived\n // from buf.\n uint8_t* bounds[2];\n } private_impl;\n} wuffs_base__io_writer;\n\nstatic inline wuffs_base__io_reader wuffs_base__io_buffer__reader(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\nstatic inline wuffs_base__io_writer wuffs_base__io_buffer__writer(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n ret.private_impl.buf = buf;\n return ret;\n}\n\n" +
@@ -79,17 +78,17 @@ const basePublicH = "" +
" inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\n" +
"" +
"// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n uint32_t num_loops;\n } private_impl;\n} wuffs_base__image_config;\n\n// TODO: Should this function return bool? An error type?\nstatic inline void wuffs_base__image_config__initialize(\n wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops) {\n if (!c) {\n return;\n }\n if (pixfmt) {\n uint64_t wh = ((uint64_t)width) * ((uint64_t)height);\n // TODO: handle things other than 1 byte per pixel.\n if (wh <= ((uint64_t)SIZE_MAX)) {\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_imp" +
"l.num_loops = num_loops;\n return;\n }\n }\n *c = ((wuffs_base__image_config){});\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling\nwuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds(\n wuffs_base__image_config* c) {\n return c ? ((wuffs_base__rect_ie_u32){\n .min_inclusive_x = 0,\n .min_inclusive_y = 0,\n .max_exclusive_x = c->private_impl.width,\n .max_exclusive_y = c->privat" +
"e_impl.height,\n })\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.num_loops : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (c) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\n" +
"l.num_loops = num_loops;\n return;\n }\n }\n *c = ((wuffs_base__image_config){});\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n return c && c->private_impl.pixfmt;\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling\nwuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {\n return c ? c->private_impl.pixsub : 0;\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_config__bounds(\n wuffs_base__image_config* c) {\n return c ? ((wuffs_base__rect_ie_u32){\n .min_incl_x = 0,\n .min_incl_y = 0,\n .max_excl_x = c->private_impl.width,\n .max_excl_y = c->private_impl.height,\n " +
" })\n : ((wuffs_base__rect_ie_u32){});\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.num_loops : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (c) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\n" +
"" +
"// --------\n\n// wuffs_base__animation_disposal encodes, for an animated image, how to\n// dispose of a frame after displaying it:\n// - None means to draw the next frame on top of this one.\n// - Restore Background means to clear the frame's dirty rectangle to \"the\n// background color\" (in practice, this means transparent black) before\n// drawing the next frame.\n// - Restore Previous means to undo the current frame, so that the next frame\n// is drawn on top of the previous one.\ntypedef uint8_t wuffs_base__animation_disposal;\n\n#define WUFFS_BASE__ANIMATION_DISPOSAL__NONE ((wuffs_base__animation_disposal)0)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND \\\n ((wuffs_base__animation_disposal)1)\n#define WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS \\\n ((wuffs_base__animation_disposal)2)\n\n" +
"" +
"// --------\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__image_config config;\n uint32_t loop_count; // 0-based count of the current loop.\n wuffs_base__pixel_buffer pixbuf;\n // TODO: color spaces.\n wuffs_base__rect_ie_u32 dirty_rect;\n wuffs_base__flicks duration;\n bool blend;\n wuffs_base__animation_disposal disposal;\n bool palette_changed;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__set_from_pixbuf(\n wuffs_base__image_buffer* b,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!b) {\n return;\n }\n *b = ((wuffs_base__image_buffer){});\n b->private_impl.config = config;\n b->private_impl.pixbuf = pixbuf;\n}\n\n// TODO: Should this function return bool? An error type?\nstatic inline void wuffs_base__image_buffer__set_from_slice(\n wuffs_base__image_buff" +
"er* b,\n wuffs_base__image_config config,\n wuffs_base__slice_u8 pixbuf_memory) {\n if (!b) {\n return;\n }\n *b = ((wuffs_base__image_buffer){});\n // TODO: don't assume 1 byte per pixel. Don't assume packed.\n uint64_t wh = ((uint64_t)config.private_impl.width) *\n ((uint64_t)config.private_impl.height);\n if (wh > pixbuf_memory.len) {\n return;\n }\n b->private_impl.config = config;\n wuffs_base__table_u8* tab = &b->private_impl.pixbuf.planes[0];\n tab->ptr = pixbuf_memory.ptr;\n tab->width = config.private_impl.width;\n tab->height = config.private_impl.height;\n tab->stride = config.private_impl.width;\n}\n\n// The palette argument is ignored unless its length is exactly 1024.\nstatic inline void wuffs_base__image_buffer__update(\n wuffs_base__image_buffer* b,\n wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n bool blend,\n wuffs_base__animation_disposal disposal,\n wuffs_base__slice_u8 palette) {\n if (!b) {\n return;\n }\n\n // Clip the dirty_rect to t" +
"he image bounds.\n dirty_rect.max_exclusive_x = wuffs_base__u32__min(\n dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);\n dirty_rect.max_exclusive_y = wuffs_base__u32__min(\n dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);\n b->private_impl.dirty_rect = dirty_rect;\n\n b->private_impl.duration = duration;\n b->private_impl.blend = blend;\n b->private_impl.disposal = disposal;\n b->private_impl.palette_changed = palette.ptr && (palette.len == 1024);\n if (b->private_impl.palette_changed) {\n memmove(b->private_impl.palette, palette.ptr, 1024);\n }\n}\n\n// wuffs_base__image_buffer__loop returns whether the image decoder should loop\n// back to the beginning of the animation, assuming that we've reached the end\n// of the encoded stream. If so, it increments b's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* b) {\n if (!b) {\n return false;\n }\n uint32_t n = b->private_impl.config." +
"private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (b->private_impl.loop_count < n - 1) {\n b->private_impl.loop_count++;\n return true;\n }\n return false;\n}\n\n// wuffs_base__image_config returns the overall configuration for this frame.\nstatic inline wuffs_base__image_config* wuffs_base__image_buffer__image_config(\n wuffs_base__image_buffer* b) {\n return b ? &b->private_impl.config : NULL;\n}\n\n// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n wuffs_base__image_buffer* b) {\n return b ? b->private" +
"_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__blend returns, for a transparent image, whether to\n// blend this frame with the existing canvas.\n//\n// In Porter-Duff compositing operator terminology, false means \"src\" and true\n// means \"src over dst\".\nstatic inline bool wuffs_base__image_buffer__blend(\n wuffs_base__image_buffer* b) {\n return b && b->private_impl.blend;\n}\n\n// wuffs_base__image_buffer__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal wuffs_base__image_buffer__disposal(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.disposal : 0;\n}\n\n// wuffs_base__image_buffer__palette_changed returns whether this frame's\n// palette differs from the previous frame. It is conservative and may return\n// false positives (but never false negatives).\nstatic inline bool wuffs_base__image_buffer__palette_changed(\n wuffs_base__image_buffer* b) {\n return b && b->private_impl.palette_changed;\n}\n\n// wuffs_" +
"base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside b and has length 1024.\nstatic inline wuffs_base__slice_u8 wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* b) {\n return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,\n .len = 1024})\n : ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__table_u8 wuffs_base__image_buffer__plane(\n wuffs_base__image_buffer* b,\n uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.pixbuf.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#endif // WUFFS_BASE_PUBLIC_H\n" +
"he image bounds.\n dirty_rect.max_excl_x = wuffs_base__u32__min(\n dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);\n dirty_rect.max_excl_y = wuffs_base__u32__min(\n dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);\n b->private_impl.dirty_rect = dirty_rect;\n\n b->private_impl.duration = duration;\n b->private_impl.blend = blend;\n b->private_impl.disposal = disposal;\n b->private_impl.palette_changed = palette.ptr && (palette.len == 1024);\n if (b->private_impl.palette_changed) {\n memmove(b->private_impl.palette, palette.ptr, 1024);\n }\n}\n\n// wuffs_base__image_buffer__loop returns whether the image decoder should loop\n// back to the beginning of the animation, assuming that we've reached the end\n// of the encoded stream. If so, it increments b's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* b) {\n if (!b) {\n return false;\n }\n uint32_t n = b->private_impl.config.private_impl.num_loo" +
"ps;\n if (n == 0) {\n return true;\n }\n if (b->private_impl.loop_count < n - 1) {\n b->private_impl.loop_count++;\n return true;\n }\n return false;\n}\n\n// wuffs_base__image_config returns the overall configuration for this frame.\nstatic inline wuffs_base__image_config* wuffs_base__image_buffer__image_config(\n wuffs_base__image_buffer* b) {\n return b ? &b->private_impl.config : NULL;\n}\n\n// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.duration : 0;\n" +
"}\n\n// wuffs_base__image_buffer__blend returns, for a transparent image, whether to\n// blend this frame with the existing canvas.\n//\n// In Porter-Duff compositing operator terminology, false means \"src\" and true\n// means \"src over dst\".\nstatic inline bool wuffs_base__image_buffer__blend(\n wuffs_base__image_buffer* b) {\n return b && b->private_impl.blend;\n}\n\n// wuffs_base__image_buffer__disposal returns, for an animated image, how to\n// dispose of this frame after displaying it.\nstatic inline wuffs_base__animation_disposal wuffs_base__image_buffer__disposal(\n wuffs_base__image_buffer* b) {\n return b ? b->private_impl.disposal : 0;\n}\n\n// wuffs_base__image_buffer__palette_changed returns whether this frame's\n// palette differs from the previous frame. It is conservative and may return\n// false positives (but never false negatives).\nstatic inline bool wuffs_base__image_buffer__palette_changed(\n wuffs_base__image_buffer* b) {\n return b && b->private_impl.palette_changed;\n}\n\n// wuffs_base__image_buffer__" +
"palette returns the palette that the pixel data\n// can index. The backing array is inside b and has length 1024.\nstatic inline wuffs_base__slice_u8 wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* b) {\n return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,\n .len = 1024})\n : ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__table_u8 wuffs_base__image_buffer__plane(\n wuffs_base__image_buffer* b,\n uint32_t p) {\n return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))\n ? b->private_impl.pixbuf.planes[p]\n : ((wuffs_base__table_u8){});\n}\n\n#endif // WUFFS_BASE_PUBLIC_H\n" +
""
const basePrivateH = "" +
@@ -110,9 +109,8 @@ const basePrivateH = "" +
"" +
"// --------\n\nstatic inline wuffs_base__slice_u8 wuffs_base__table_u8__row(\n wuffs_base__table_u8 t,\n uint32_t y) {\n if (y < t.height) {\n return ((wuffs_base__slice_u8){\n .ptr = t.ptr + (t.stride * y),\n .len = t.width,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n" +
"" +
"// ---------------- Utility\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(\n wuffs_base__utility* ignored,\n uint32_t min_inclusive,\n uint32_t max_inclusive) {\n return ((wuffs_base__range_ii_u32){\n .min_inclusive = min_inclusive,\n .max_inclusive = max_inclusive,\n });\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__utility__make_range_ie_u32(\n wuffs_base__utility* ignored,\n uint32_t min_inclusive,\n uint32_t max_exclusive) {\n return ((wuffs_base__range_ie_u32){\n .min_inclusive = min_inclusive,\n .max_exclusive = max_exclusive,\n });\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__utility__make_range_ii_u64(\n wuffs_base__utility* ignored,\n uint64_t min_inclusive,\n uint64_t max_inclusive) {\n return ((wuffs_base__range_ii_u64){\n .min_inclusive = min_inclusive,\n .max_inclusive = max_inclusive,\n });\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__utility__make_range_ie_u64(\n wuffs_base__utility* ignored,\n" +
" uint64_t min_inclusive,\n uint64_t max_exclusive) {\n return ((wuffs_base__range_ie_u64){\n .min_inclusive = min_inclusive,\n .max_exclusive = max_exclusive,\n });\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32(\n wuffs_base__utility* ignored,\n uint32_t min_inclusive_x,\n uint32_t min_inclusive_y,\n uint32_t max_inclusive_x,\n uint32_t max_inclusive_y) {\n return ((wuffs_base__rect_ii_u32){\n .min_inclusive_x = min_inclusive_x,\n .min_inclusive_y = min_inclusive_y,\n .max_inclusive_x = max_inclusive_x,\n .max_inclusive_y = max_inclusive_y,\n });\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(\n wuffs_base__utility* ignored,\n uint32_t min_inclusive_x,\n uint32_t min_inclusive_y,\n uint32_t max_exclusive_x,\n uint32_t max_exclusive_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_inclusive_x = min_inclusive_x,\n .min_inclusive_y = min_inclusive_y,\n .max_exclusive_x = max_exclusive_x,\n" +
" .max_exclusive_y = max_exclusive_y,\n });\n}\n\n" +
"// ---------------- Utility\n\nstatic inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_incl) {\n return ((wuffs_base__range_ii_u32){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u32 wuffs_base__utility__make_range_ie_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl,\n uint32_t max_excl) {\n return ((wuffs_base__range_ie_u32){\n .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__range_ii_u64 wuffs_base__utility__make_range_ii_u64(\n wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_incl) {\n return ((wuffs_base__range_ii_u64){\n .min_incl = min_incl,\n .max_incl = max_incl,\n });\n}\n\nstatic inline wuffs_base__range_ie_u64 wuffs_base__utility__make_range_ie_u64(\n wuffs_base__utility* ignored,\n uint64_t min_incl,\n uint64_t max_excl) {\n return ((wuffs_base__range_ie_u64){\n " +
" .min_incl = min_incl,\n .max_excl = max_excl,\n });\n}\n\nstatic inline wuffs_base__rect_ii_u32 wuffs_base__utility__make_rect_ii_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_incl_x,\n uint32_t max_incl_y) {\n return ((wuffs_base__rect_ii_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_incl_x = max_incl_x,\n .max_incl_y = max_incl_y,\n });\n}\n\nstatic inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(\n wuffs_base__utility* ignored,\n uint32_t min_incl_x,\n uint32_t min_incl_y,\n uint32_t max_excl_x,\n uint32_t max_excl_y) {\n return ((wuffs_base__rect_ie_u32){\n .min_incl_x = min_incl_x,\n .min_incl_y = min_incl_y,\n .max_excl_x = max_excl_x,\n .max_excl_y = max_excl_y,\n });\n}\n\n" +
"" +
"// ---------------- I/O\n\nstatic inline bool wuffs_base__io_buffer__is_valid(wuffs_base__io_buffer buf) {\n return (buf.ptr || (buf.len == 0)) && (buf.len >= buf.wi) &&\n (buf.wi >= buf.ri);\n}\n\nstatic inline bool wuffs_base__io_reader__is_eof(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n return buf && buf->closed && (buf->ptr + buf->wi == o.private_impl.bounds[1]);\n}\n\nstatic inline bool wuffs_base__io_reader__is_valid(wuffs_base__io_reader o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) bounds.\n return buf ? ((buf->ptr <= o.private_impl.bounds[0]) &&\n (o.private_impl.bounds[0] <= o.private_impl.bounds[1]) &&\n (o.private_impl.bounds[1] <= buf->ptr + buf->len))\n : ((o.private_impl.bounds[0] == NULL) &&\n (o.private_impl.bounds[1] == NULL));\n}\n\nstatic inline bool wuf" +
"fs_base__io_writer__is_valid(wuffs_base__io_writer o) {\n wuffs_base__io_buffer* buf = o.private_impl.buf;\n // Note: if making this function public (i.e. moving it to base-header.h), it\n // also needs to allow NULL (i.e. implicit, callee-calculated) bounds.\n return buf ? ((buf->ptr <= o.private_impl.bounds[0]) &&\n (o.private_impl.bounds[0] <= o.private_impl.bounds[1]) &&\n (o.private_impl.bounds[1] <= buf->ptr + buf->len))\n : ((o.private_impl.bounds[0] == NULL) &&\n (o.private_impl.bounds[1] == NULL));\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling" +
+4 -5
View File
@@ -128,12 +128,11 @@ void compose(wuffs_base__image_buffer* ib) {
wuffs_base__rect_ie_u32 bounds = wuffs_base__image_buffer__dirty_rect(ib);
size_t y;
for (y = bounds.min_inclusive_y; y < bounds.max_exclusive_y; y++) {
for (y = bounds.min_incl_y; y < bounds.max_excl_y; y++) {
size_t x;
wuffs_base__color_u32argb* d =
dst_buffer + (y * width) + bounds.min_inclusive_x;
uint8_t* s = image_buffer + (y * width) + bounds.min_inclusive_x;
for (x = bounds.min_inclusive_x; x < bounds.max_exclusive_x; x++) {
wuffs_base__color_u32argb* d = dst_buffer + (y * width) + bounds.min_incl_x;
uint8_t* s = image_buffer + (y * width) + bounds.min_incl_x;
for (x = bounds.min_incl_x; x < bounds.max_excl_x; x++) {
uint32_t index = *s++;
wuffs_base__color_u32argb c = load_u32le(palette + 4 * index);
if (c) {
+84 -110
View File
@@ -315,20 +315,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -336,14 +335,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -356,28 +355,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -385,14 +383,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -405,33 +403,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -439,14 +436,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -459,28 +456,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -488,14 +484,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -508,14 +504,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -523,31 +519,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -555,21 +548,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -582,14 +571,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -598,7 +583,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -606,24 +591,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -631,21 +613,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -658,25 +636,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1057,10 +1031,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1179,10 +1153,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1611,69 +1585,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1611,69 +1585,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1699,69 +1673,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1813,69 +1787,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1851,69 +1825,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1635,69 +1609,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+116 -142
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
@@ -1849,69 +1823,69 @@ static inline wuffs_base__slice_u8 wuffs_base__table_u8__row(
static inline wuffs_base__range_ii_u32 wuffs_base__utility__make_range_ii_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive,
uint32_t max_inclusive) {
uint32_t min_incl,
uint32_t max_incl) {
return ((wuffs_base__range_ii_u32){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint32_t max_exclusive) {
uint32_t min_incl,
uint32_t max_excl) {
return ((wuffs_base__range_ie_u32){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive,
uint64_t max_inclusive) {
uint64_t min_incl,
uint64_t max_incl) {
return ((wuffs_base__range_ii_u64){
.min_inclusive = min_inclusive,
.max_inclusive = max_inclusive,
.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_inclusive,
uint64_t max_exclusive) {
uint64_t min_incl,
uint64_t max_excl) {
return ((wuffs_base__range_ie_u64){
.min_inclusive = min_inclusive,
.max_exclusive = max_exclusive,
.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_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_inclusive_x,
uint32_t max_inclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_inclusive_x = max_inclusive_x,
.max_inclusive_y = max_inclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_incl_x = max_incl_x,
.max_incl_y = max_incl_y,
});
}
static inline wuffs_base__rect_ie_u32 wuffs_base__utility__make_rect_ie_u32(
wuffs_base__utility* ignored,
uint32_t min_inclusive_x,
uint32_t min_inclusive_y,
uint32_t max_exclusive_x,
uint32_t max_exclusive_y) {
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_inclusive_x = min_inclusive_x,
.min_inclusive_y = min_inclusive_y,
.max_exclusive_x = max_exclusive_x,
.max_exclusive_y = max_exclusive_y,
.min_incl_x = min_incl_x,
.min_incl_y = min_incl_y,
.max_excl_x = max_excl_x,
.max_excl_y = max_excl_y,
});
}
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+84 -110
View File
@@ -304,20 +304,19 @@ typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
uint32_t min_incl;
uint32_t max_incl;
} wuffs_base__range_ii_u32;
static inline bool wuffs_base__range_ii_u32__is_empty(
wuffs_base__range_ii_u32 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -325,14 +324,14 @@ static inline bool wuffs_base__range_ii_u32__equals(
static inline bool wuffs_base__range_ii_u32__contains(
wuffs_base__range_ii_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection(
wuffs_base__range_ii_u32 r,
wuffs_base__range_ii_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__min(r.max_incl, s.max_incl);
return r;
}
@@ -345,28 +344,27 @@ static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union(
if (wuffs_base__range_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u32__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
uint32_t min_incl;
uint32_t max_excl;
} wuffs_base__range_ie_u32;
static inline bool wuffs_base__range_ie_u32__is_empty(
wuffs_base__range_ie_u32 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -374,14 +372,14 @@ static inline bool wuffs_base__range_ie_u32__equals(
static inline bool wuffs_base__range_ie_u32__contains(
wuffs_base__range_ie_u32 r,
uint32_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection(
wuffs_base__range_ie_u32 r,
wuffs_base__range_ie_u32 s) {
r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__min(r.max_excl, s.max_excl);
return r;
}
@@ -394,33 +392,32 @@ static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union(
if (wuffs_base__range_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u32__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u32__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u32__sat_sub(r.max_excl, r.min_incl);
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
uint64_t min_incl;
uint64_t max_incl;
} wuffs_base__range_ii_u64;
static inline bool wuffs_base__range_ii_u64__is_empty(
wuffs_base__range_ii_u64 r) {
return r.min_inclusive > r.max_inclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_inclusive == s.max_inclusive) ||
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));
}
@@ -428,14 +425,14 @@ static inline bool wuffs_base__range_ii_u64__equals(
static inline bool wuffs_base__range_ii_u64__contains(
wuffs_base__range_ii_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x <= r.max_inclusive);
return (r.min_incl <= x) && (x <= r.max_incl);
}
static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection(
wuffs_base__range_ii_u64 r,
wuffs_base__range_ii_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__min(r.max_incl, s.max_incl);
return r;
}
@@ -448,28 +445,27 @@ static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union(
if (wuffs_base__range_ii_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_incl = wuffs_base__u64__max(r.max_incl, s.max_incl);
return r;
}
// --------
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
uint64_t min_incl;
uint64_t max_excl;
} wuffs_base__range_ie_u64;
static inline bool wuffs_base__range_ie_u64__is_empty(
wuffs_base__range_ie_u64 r) {
return r.min_inclusive >= r.max_exclusive;
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) {
return (r.min_inclusive == s.min_inclusive &&
r.max_exclusive == s.max_exclusive) ||
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));
}
@@ -477,14 +473,14 @@ static inline bool wuffs_base__range_ie_u64__equals(
static inline bool wuffs_base__range_ie_u64__contains(
wuffs_base__range_ie_u64 r,
uint64_t x) {
return (r.min_inclusive <= x) && (x < r.max_exclusive);
return (r.min_incl <= x) && (x < r.max_excl);
}
static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection(
wuffs_base__range_ie_u64 r,
wuffs_base__range_ie_u64 s) {
r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__max(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__min(r.max_excl, s.max_excl);
return r;
}
@@ -497,14 +493,14 @@ static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union(
if (wuffs_base__range_ie_u64__is_empty(s)) {
return r;
}
r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive);
r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive);
r.min_incl = wuffs_base__u64__min(r.min_incl, s.min_incl);
r.max_excl = wuffs_base__u64__max(r.max_excl, s.max_excl);
return 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_exclusive, r.min_inclusive);
return wuffs_base__u64__sat_sub(r.max_excl, r.min_incl);
}
// --------
@@ -512,31 +508,28 @@ static inline uint64_t wuffs_base__range_ie_u64__length(
// wuffs_base__rect_ii_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ii" means that the bounds are inclusive on the low end
// and inclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x <= max_inclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x <= max_incl_x)) and likewise for y.
//
// It is valid for min > max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle.
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_incl_x;
uint32_t max_incl_y;
} wuffs_base__rect_ii_u32;
static inline bool wuffs_base__rect_ii_u32__is_empty(
wuffs_base__rect_ii_u32 r) {
return (r.min_inclusive_x > r.max_inclusive_x) ||
(r.min_inclusive_y > r.max_inclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_inclusive_x == s.max_inclusive_x &&
r.max_inclusive_y == s.max_inclusive_y) ||
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));
}
@@ -544,21 +537,17 @@ static inline bool wuffs_base__rect_ii_u32__equals(wuffs_base__rect_ii_u32 r,
static inline bool wuffs_base__rect_ii_u32__contains(wuffs_base__rect_ii_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x <= r.max_inclusive_x) &&
(r.min_inclusive_y <= y) && (y <= r.max_inclusive_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__intersection(
wuffs_base__rect_ii_u32 r,
wuffs_base__rect_ii_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__min(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__min(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -571,14 +560,10 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
if (wuffs_base__rect_ii_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_inclusive_x =
wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x);
r.max_inclusive_y =
wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_incl_x = wuffs_base__u32__max(r.max_incl_x, s.max_incl_x);
r.max_incl_y = wuffs_base__u32__max(r.max_incl_y, s.max_incl_y);
return r;
}
@@ -587,7 +572,7 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
// wuffs_base__rect_ie_u32 is a rectangle (a 2-dimensional range) on the
// integer grid. The "ie" means that the bounds are inclusive on the low end
// and exclusive on the high end. It contains all points (x, y) such that
// ((min_inclusive_x <= x) && (x < max_exclusive_x)) and likewise for y.
// ((min_incl_x <= x) && (x < max_excl_x)) and likewise for y.
//
// It is valid for min >= max, in which case the rectangle is empty. There are
// multiple representations of an empty rectangle, including a value with all
@@ -595,24 +580,21 @@ static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union(
//
// The X and Y axes increase right and down.
typedef struct {
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_exclusive_x;
uint32_t max_exclusive_y;
uint32_t min_incl_x;
uint32_t min_incl_y;
uint32_t max_excl_x;
uint32_t max_excl_y;
} wuffs_base__rect_ie_u32;
static inline bool wuffs_base__rect_ie_u32__is_empty(
wuffs_base__rect_ie_u32 r) {
return (r.min_inclusive_x >= r.max_exclusive_x) ||
(r.min_inclusive_y >= r.max_exclusive_y);
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) {
return (r.min_inclusive_x == s.min_inclusive_x &&
r.min_inclusive_y == s.min_inclusive_y &&
r.max_exclusive_x == s.max_exclusive_x &&
r.max_exclusive_y == s.max_exclusive_y) ||
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));
}
@@ -620,21 +602,17 @@ static inline bool wuffs_base__rect_ie_u32__equals(wuffs_base__rect_ie_u32 r,
static inline bool wuffs_base__rect_ie_u32__contains(wuffs_base__rect_ie_u32 r,
uint32_t x,
uint32_t y) {
return (r.min_inclusive_x <= x) && (x < r.max_exclusive_x) &&
(r.min_inclusive_y <= y) && (y < r.max_exclusive_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__intersection(
wuffs_base__rect_ie_u32 r,
wuffs_base__rect_ie_u32 s) {
r.min_inclusive_x =
wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__max(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__max(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__min(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__min(r.max_excl_y, s.max_excl_y);
return r;
}
@@ -647,25 +625,21 @@ static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union(
if (wuffs_base__rect_ie_u32__is_empty(s)) {
return r;
}
r.min_inclusive_x =
wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x);
r.min_inclusive_y =
wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);
r.max_exclusive_x =
wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);
r.max_exclusive_y =
wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);
r.min_incl_x = wuffs_base__u32__min(r.min_incl_x, s.min_incl_x);
r.min_incl_y = wuffs_base__u32__min(r.min_incl_y, s.min_incl_y);
r.max_excl_x = wuffs_base__u32__max(r.max_excl_x, s.max_excl_x);
r.max_excl_y = wuffs_base__u32__max(r.max_excl_y, s.max_excl_y);
return 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_exclusive_x, r.min_inclusive_x);
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) {
return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);
return wuffs_base__u32__sat_sub(r.max_excl_y, r.min_incl_y);
}
// ---------------- I/O
@@ -1046,10 +1020,10 @@ wuffs_base__image_config__pixel_subsampling(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_inclusive_x = 0,
.min_inclusive_y = 0,
.max_exclusive_x = c->private_impl.width,
.max_exclusive_y = c->private_impl.height,
.min_incl_x = 0,
.min_incl_y = 0,
.max_excl_x = c->private_impl.width,
.max_excl_y = c->private_impl.height,
})
: ((wuffs_base__rect_ie_u32){});
}
@@ -1168,10 +1142,10 @@ static inline void wuffs_base__image_buffer__update(
}
// Clip the dirty_rect to the image bounds.
dirty_rect.max_exclusive_x = wuffs_base__u32__min(
dirty_rect.max_exclusive_x, b->private_impl.config.private_impl.width);
dirty_rect.max_exclusive_y = wuffs_base__u32__min(
dirty_rect.max_exclusive_y, b->private_impl.config.private_impl.height);
dirty_rect.max_excl_x = wuffs_base__u32__min(
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
dirty_rect.max_excl_y = wuffs_base__u32__min(
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
b->private_impl.dirty_rect = dirty_rect;
b->private_impl.duration = duration;
+6 -8
View File
@@ -118,14 +118,12 @@ var Funcs = []string{
// ---- utility
"utility.make_range_ii_u32(min_inclusive u32, max_inclusive u32)(ret range_ii_u32)",
"utility.make_range_ie_u32(min_inclusive u32, max_exclusive u32)(ret range_ie_u32)",
"utility.make_range_ii_u64(min_inclusive u64, max_inclusive u64)(ret range_ii_u64)",
"utility.make_range_ie_u64(min_inclusive u64, max_exclusive u64)(ret range_ie_u64)",
"utility.make_rect_ii_u32(min_inclusive_x u32, min_inclusive_y u32," +
"max_inclusive_x u32, max_inclusive_y u32)(ret rect_ii_u32)",
"utility.make_rect_ie_u32(min_inclusive_x u32, min_inclusive_y u32," +
"max_exclusive_x u32, max_exclusive_y u32)(ret rect_ie_u32)",
"utility.make_range_ii_u32(min_incl u32, max_incl u32)(ret range_ii_u32)",
"utility.make_range_ie_u32(min_incl u32, max_excl u32)(ret range_ie_u32)",
"utility.make_range_ii_u64(min_incl u64, max_incl u64)(ret range_ii_u64)",
"utility.make_range_ie_u64(min_incl u64, max_excl u64)(ret range_ie_u64)",
"utility.make_rect_ii_u32(min_incl_x u32, min_incl_y u32, max_incl_x u32, max_incl_y u32)(ret rect_ii_u32)",
"utility.make_rect_ie_u32(min_incl_x u32, min_incl_y u32, max_excl_x u32, max_excl_y u32)(ret rect_ie_u32)",
// ---- image_buffer
+5 -5
View File
@@ -126,7 +126,7 @@ pub func decoder.decode_config?(dst ptr base.image_config, src base.io_reader)()
}
pub func decoder.work_buffer_size()(ret base.range_ii_u64) {
return this.util.make_range_ii_u64(min_inclusive:0, max_inclusive:0)
return this.util.make_range_ii_u64(min_incl:0, max_incl:0)
}
pub func decoder.decode_frame?(dst ptr base.image_buffer, src base.io_reader, work_buffer slice base.u8)() {
@@ -534,10 +534,10 @@ pri func decoder.decode_id_part1?(dst ptr base.image_buffer, src base.io_reader)
// palette update is necessary.
}
in.dst.update!(dirty_rect:this.util.make_rect_ie_u32(
min_inclusive_x:this.frame_rect_x0,
min_inclusive_y:this.frame_rect_y0,
max_exclusive_x:this.frame_rect_x1,
max_exclusive_y:this.frame_rect_y1),
min_incl_x:this.frame_rect_x0,
min_incl_y:this.frame_rect_y0,
max_excl_x:this.frame_rect_x1,
max_excl_y:this.frame_rect_y1),
duration:this.gc_duration, blend:true, disposal:this.gc_disposal, palette:palette)
this.previous_use_global_palette = not (use_local_palette or this.gc_has_transparent_index)
+3 -3
View File
@@ -466,9 +466,9 @@ bool do_test_wuffs_gif_decode_animated(
FAIL("decode_frame #%" PRIu32 ": dirty_rect: got (%" PRIu32 ", %" PRIu32
")-(%" PRIu32 ", %" PRIu32 "), want (%" PRIu32 ", %" PRIu32
")-(%" PRIu32 ", %" PRIu32 ")",
i, got.min_inclusive_x, got.min_inclusive_y, got.max_exclusive_x,
got.max_exclusive_y, want.min_inclusive_x, want.min_inclusive_y,
want.max_exclusive_x, want.max_exclusive_y);
i, got.min_incl_x, got.min_incl_y, got.max_excl_x, got.max_excl_y,
want.min_incl_x, want.min_incl_y, want.max_excl_x,
want.max_excl_y);
return false;
}
}
+8 -9
View File
@@ -296,10 +296,10 @@ wuffs_base__rect_ie_u32 make_rect_ie_u32(uint32_t x0,
uint32_t x1,
uint32_t y1) {
wuffs_base__rect_ie_u32 ret;
ret.min_inclusive_x = x0;
ret.min_inclusive_y = y0;
ret.max_exclusive_x = x1;
ret.max_exclusive_y = y1;
ret.min_incl_x = x0;
ret.min_incl_y = y0;
ret.max_excl_x = x1;
ret.max_excl_y = y1;
return ret;
}
@@ -339,17 +339,16 @@ const char* copy_to_io_buffer_from_image_buffer(wuffs_base__io_buffer* dst,
wuffs_base__table_u8 tab = wuffs_base__image_buffer__plane(src, p);
wuffs_base__rect_ie_u32 r = wuffs_base__image_buffer__dirty_rect(src);
uint32_t y;
for (y = r.min_inclusive_y; y < r.max_exclusive_y; y++) {
for (y = r.min_incl_y; y < r.max_excl_y; y++) {
wuffs_base__slice_u8 row = wuffs_base__table_u8__row(tab, y);
if ((r.min_inclusive_x >= r.max_exclusive_x) ||
(r.max_exclusive_x > row.len)) {
if ((r.min_incl_x >= r.max_excl_x) || (r.max_excl_x > row.len)) {
break;
}
uint32_t n = r.max_exclusive_x - r.min_inclusive_x;
uint32_t n = r.max_excl_x - r.min_incl_x;
if (n > (dst->len - dst->wi)) {
return "copy_to_io_buffer_from_image_buffer: dst buffer is too small";
}
memmove(dst->ptr + dst->wi, row.ptr + r.min_inclusive_x, n);
memmove(dst->ptr + dst->wi, row.ptr + r.min_incl_x, n);
dst->wi += n;
}
}