Add range_ii, range_ie types and sat arithmetic

This commit is contained in:
Nigel Tao committed 2018-04-12 19:11:40 +10:00
1 parent e4c4f5ce62
commit fee97df698
12 files changed
+1864 -219

No files matched your search

+167 -18
View File
@@ -53,27 +53,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -494,7 +643,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -514,7 +663,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -550,9 +699,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+27 -21
View File
@@ -18,27 +18,33 @@ package cgen
const baseHeader = "" +
"#ifndef WUFFS_BASE_HEADER_H\n#define WUFFS_BASE_HEADER_H\n\n// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include <stdbool.h>\n#include <stdint.h>\n#include <string.h>\n\n// Wuffs requires a word size of at least 32 bits because it assumes that\n// converting a u32 to usize will never overflow. For example, the size of a\n// decoded image is often represented, explicitly or implicitly in an image\n// file, as a u32, and it is convenient to compare that to a buffer size.\n//\n// Si" +
"milarly, the word size is at most 64 bits because it assumes that\n// converting a usize to u64 will never overflow.\n#if __WORDSIZE < 32\n#error \"Wuffs requires a word size of at least 32 bits\"\n#elif __WORDSIZE > 64\n#error \"Wuffs requires a word size of at most 64 bits\"\n#endif\n\n// WUFFS_VERSION is the major.minor version number as a uint32. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define WUFFS_VERSION 0x00001\n\n// ---------------- Fundamentals\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef uint64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL\n\n// wuffs_base__rectangle is a rectangle on the integer grid. It contains all\n// p" +
"oints (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It\n// is therefore empty if min_x >= max_x. There are multiple representations of\n// an empty rectangle.\n//\n// A value with all fields zero is a valid, empty rectangle.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_x;\n uint32_t min_y;\n uint32_t max_x;\n uint32_t max_y;\n} wuffs_base__rectangle;\n\nstatic inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {\n return r.max_x > r.min_x ? r.max_x - r.min_x : 0;\n}\n\nstatic inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {\n return r.max_y > r.min_y ? r.max_y - r.min_y : 0;\n}\n\n// wuffs_base__slice_u8 is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\ntypedef struct {\n uint8_t* ptr;\n size_t len;\n} wuffs_base__slice_u8;\n\n// wuffs_base__table_u8 is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\ntypedef struct {\n uint8_t* ptr;\n size_" +
"t width;\n size_t height;\n size_t stride;\n} wuffs_base__table_u8;\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\n// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__io_limit {\n uint64_t* ptr_to_len; // Pointer to N.\n struct wuffs_base__io_limi" +
"t* next; // Linked list of limits.\n} wuffs_base__io_limit;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\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_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\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_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n" +
"\n// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The bit fields of a wuffs_bas" +
"e__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats with N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index). The distance\n// between " +
"successive palette elements is always 4 bytes.\n//\n// The color field is encoded in 3 bits:\n// - 0 means A (Alpha).\n// - 1 means Y or YA (Gray, Alpha).\n// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha).\n// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha).\n// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha).\n// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black).\n// - all other values are reserved.\n//\n// In Wuffs, channels are given in memory order, regardless of endianness,\n// since the C type for the pixel data is an array of bytes, not an array of\n// uint32_t. For example, packed BGRA with 8 bits per channel means that the\n// bytes in memory are always Blue, Green, Red then Alpha. On big-endian\n// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB.\n//\n// When the color field (3 bits) encodes multiple options, the transparency\n// field (2 bits) distinguishes them:\n// - 0 means fully opaque, no " +
"extra channels\n// - 1 means fully opaque, one extra channel (X or K, padding or black).\n// - 2 means one extra alpha channel, other channels are non-premultiplied.\n// - 3 means one extra alpha channel, other channels are premultiplied.\n//\n// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is\n// invalid to combine the zero color (alpha only) with the zero transparency.\n//\n// Bit depth is encoded in 4 bits:\n// - 0 means the channel or index is unused.\n// - x means a bit depth of x, for x in the range 1..8.\n// - 9 means a bit depth of 10.\n// - 10 means a bit depth of 12.\n// - 11 means a bit depth of 16.\n// - 12 means a bit depth of 24.\n// - 13 means a bit depth of 32.\n// - 14 means a bit depth of 48.\n// - 15 means a bit depth of 64.\n//\n// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for\n// decoding a PNG image - network byte order (also known as big-endian),\n// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor\n// with" +
" alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel format value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and the Wayland-DRM library's " +
"WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base" +
"__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMU" +
"L \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_base__pixel_format f) {\n " +
" return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >> shift_y.\n// where biases" +
" and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-image may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE " +
"((wuffs_base__pixel_subsampling)0);\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x202000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100);\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsam" +
"pling__bias_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\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\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 // TODO: move the check from wuffs_base__image_config__is_v" +
"alid here. Should\n // this function return bool? An error type?\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_impl.num_loops = num_loops;\n}\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 if (!c || !c->private_impl.pixfmt) {\n return false;\n }\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 //\n // TODO: move the check to wuffs_base__image_config__initialize.\n return wh <= ((uint64_t)SIZE_MAX);\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__i" +
"mage_config__pixel_subsampling(wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(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 wuffs_base__image_config__is_valid(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 wuffs_base__image_config__is_valid(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 (wuffs_base__image_config__is_va" +
"lid(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\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__rectangle dirty_rect;\n wuffs_base__flicks duration;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__initialize(\n wuffs_base__image_buffer* f,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!f) {\n return;\n }\n *f = ((wuffs_base__image_buffer){});\n f->private_impl.config = config;\n f->private_impl.pixbuf = pixbuf;\n}\n\nstatic inline void wuffs_base__image_buffer__u" +
"pdate(\n wuffs_base__image_buffer* f,\n wuffs_base__rectangle dirty_rect,\n wuffs_base__flicks duration,\n uint8_t* palette_ptr,\n size_t palette_len) {\n if (!f) {\n return;\n }\n f->private_impl.dirty_rect = dirty_rect;\n f->private_impl.duration = duration;\n if (palette_ptr) {\n memmove(f->private_impl.palette, palette_ptr,\n palette_len <= 1024 ? palette_len : 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 f's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {\n if (!f) {\n return false;\n }\n uint32_t n = f->private_impl.config.private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (f->private_impl.loop_count < n - 1) {\n f->private_impl.loop_count++;\n return true;\n }\n return false;\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__rectangle wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){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* f) {\n return f ? f->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside f and has length 1024.\nstatic inline uint8_t* wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.palette : NULL;\n}\n\n#endif // WUFFS_BASE_HEADER_H\n" +
"milarly, the word size is at most 64 bits because it assumes that\n// converting a usize to u64 will never overflow.\n#if __WORDSIZE < 32\n#error \"Wuffs requires a word size of at least 32 bits\"\n#elif __WORDSIZE > 64\n#error \"Wuffs requires a word size of at most 64 bits\"\n#endif\n\n// WUFFS_VERSION is the major.minor version number as a uint32. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define WUFFS_VERSION 0x00001\n\n// ---------------- Fundamentals\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef uint64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL\n\n// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms\n/" +
"/ are per https://locklessinc.com/articles/sat_arithmetic/\n//\n// It is important that the underlying types are unsigned integers, as signed\n// integer arithmetic overflow is undefined behavior in C.\n\nstatic inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {\n uint32_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {\n uint32_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\nstatic inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {\n uint64_t res = x + y;\n res |= -(res < x);\n return res;\n}\n\nstatic inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {\n uint64_t res = x - y;\n res &= -(res <= x);\n return res;\n}\n\n// 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-closed-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, aga" +
"in 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__contains(\n wuffs_base__range_ii_u32 r,\n uint32_t x) {\n return (r.min_inclusive <= x) && (x <= r.max_inclusive);\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__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 inl" +
"ine 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\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__contains(\n wuffs_base__range_ii_u64 r,\n uint64_t x) {\n return (r.min_inclusive <= x) && (x <= r.max_inclusive);\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__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 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// 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__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\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__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 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// wuffs_base__slice_u8 is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\ntypedef struct {\n uint8_t* ptr;\n size_t len;\n} wuffs_base__slice_u8;\n\n// wuffs_base__table_u8 is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\ntypedef struct {\n uint8_t* ptr;\n size_t width;\n size_t height;\n size_t stride;\n} wuffs_base__table_u8;\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\n//" +
" wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__io_limit {\n uint64_t* ptr_to_len; // Pointer to N.\n struct wuffs_base__io_limit* next; // Linked list of limits.\n} wuffs_base__io_limit;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\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_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // TODO: move" +
" buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\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_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n\n// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 " +
"encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The bit fields of a wuffs_base__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats wi" +
"th N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index). The distance\n// between successive palette elements is always 4 bytes.\n//\n// The color field is encoded in 3 bits:\n// - 0 means A (Alpha).\n// - 1 means Y or YA (Gray, Alpha).\n// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha).\n// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha).\n// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha).\n// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black).\n// - all other values are reserved.\n//\n// In Wuffs, channels are given in memory order, regardless of endianness,\n/" +
"/ since the C type for the pixel data is an array of bytes, not an array of\n// uint32_t. For example, packed BGRA with 8 bits per channel means that the\n// bytes in memory are always Blue, Green, Red then Alpha. On big-endian\n// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB.\n//\n// When the color field (3 bits) encodes multiple options, the transparency\n// field (2 bits) distinguishes them:\n// - 0 means fully opaque, no extra channels\n// - 1 means fully opaque, one extra channel (X or K, padding or black).\n// - 2 means one extra alpha channel, other channels are non-premultiplied.\n// - 3 means one extra alpha channel, other channels are premultiplied.\n//\n// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is\n// invalid to combine the zero color (alpha only) with the zero transparency.\n//\n// Bit depth is encoded in 4 bits:\n// - 0 means the channel or index is unused.\n// - x means a bit depth of x, for x in the range 1..8.\n// - 9 means a bit depth " +
"of 10.\n// - 10 means a bit depth of 12.\n// - 11 means a bit depth of 16.\n// - 12 means a bit depth of 24.\n// - 13 means a bit depth of 32.\n// - 14 means a bit depth of 48.\n// - 15 means a bit depth of 64.\n//\n// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for\n// decoding a PNG image - network byte order (also known as big-endian),\n// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor\n// with alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel fo" +
"rmat value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and the Wayland-DRM library's WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these bits directly; they are private implementation\n// detai" +
"ls. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT_" +
"_BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_B" +
"ASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_base__pixel_format f) {\n return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due " +
"to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >> shift_y.\n// where biases and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-image may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// " +
"Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE ((wuffs_base__pixel_subsampling)0);\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x202000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100)" +
";\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\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_subsampl" +
"ing pixsub;\n uint32_t width;\n uint32_t height;\n uint32_t num_loops;\n } private_impl;\n} wuffs_base__image_config;\n\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 // TODO: move the check from wuffs_base__image_config__is_valid here. Should\n // this function return bool? An error type?\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_impl.num_loops = num_loops;\n}\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 if (!c || !c->private_impl.pixfmt) {\n return false;\n }\n uint64_t wh =\n ((ui" +
"nt64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n //\n // TODO: move the check to wuffs_base__image_config__initialize.\n return wh <= ((uint64_t)SIZE_MAX);\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 wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(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 wuffs_base__image_config__is_valid(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 wuffs_base__image_config__is_valid(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 (wuffs_base__image_config__is_valid(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\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 wuff" +
"s_base__flicks duration;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__initialize(\n wuffs_base__image_buffer* f,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!f) {\n return;\n }\n *f = ((wuffs_base__image_buffer){});\n f->private_impl.config = config;\n f->private_impl.pixbuf = pixbuf;\n}\n\nstatic inline void wuffs_base__image_buffer__update(\n wuffs_base__image_buffer* f,\n wuffs_base__rect_ie_u32 dirty_rect,\n wuffs_base__flicks duration,\n uint8_t* palette_ptr,\n size_t palette_len) {\n if (!f) {\n return;\n }\n f->private_impl.dirty_rect = dirty_rect;\n f->private_impl.duration = duration;\n if (palette_ptr) {\n memmove(f->private_impl.palette, palette_ptr,\n palette_len <= 1024 ? palette_len : 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 f's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {\n if (!f) {\n return false;\n }\n uint32_t n = f->private_impl.config.private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (f->private_impl.loop_count < n - 1) {\n f->private_impl.loop_count++;\n return true;\n }\n return false;\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* f) {\n return f ? f->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* f) {\n return f ? f->pri" +
"vate_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside f and has length 1024.\nstatic inline uint8_t* wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.palette : NULL;\n}\n\n#endif // WUFFS_BASE_HEADER_H\n" +
""
const baseImpl = "" +
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display
+167 -18
View File
@@ -56,27 +56,176 @@ typedef uint64_t wuffs_base__flicks;
#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL
// wuffs_base__rectangle is a rectangle on the integer grid. It contains all
// points (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It
// is therefore empty if min_x >= max_x. There are multiple representations of
// an empty rectangle.
// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms
// are per https://locklessinc.com/articles/sat_arithmetic/
//
// A value with all fields zero is a valid, empty rectangle.
// It is important that the underlying types are unsigned integers, as signed
// integer arithmetic overflow is undefined behavior in C.
static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) {
uint32_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint32_t wuffs_base__u32__sat_sub(uint32_t x, uint32_t y) {
uint32_t res = x - y;
res &= -(res <= x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_add(uint64_t x, uint64_t y) {
uint64_t res = x + y;
res |= -(res < x);
return res;
}
static inline uint64_t wuffs_base__u64__sat_sub(uint64_t x, uint64_t y) {
uint64_t res = x - y;
res &= -(res <= x);
return res;
}
// Ranges are either inclusive ("range_ii") or exclusive ("range_ie") on the
// high end. Both the "ii" and "ie" flavors are useful in practice.
//
// The "ei" and "ee" flavors also exist in theory, but aren't widely used. In
// Wuffs, the low end is always inclusive.
//
// The "ii" (closed interval) flavor is useful when refining e.g. "the set of
// all uint32_t values" to a contiguous subset: "uint32_t values in the closed
// interval [M, N]", for uint32_t values M and N. An unrefined type (in other
// words, the set of all uint32_t values) is not representable in the "ie"
// flavor because if N equals ((1<<32) - 1) then (N + 1) will overflow.
//
// On the other hand, the "ie" (half-open interval) flavor is recommended by
// Dijkstra's "Why numbering should start at zero" at
// http://www.cs.utexas.edu/users/EWD/ewd08xx/EWD831.PDF and a further
// discussion of motivating rationale is at
// https://www.quora.com/Why-are-Python-ranges-half-open-exclusive-instead-of-closed-inclusive
//
// For example, with "ie", the number of elements in "uint32_t values in the
// half-open interval [M, N)" is equal to max(0, N-M). Furthermore, that number
// of elements (in one dimension, a length, in two dimensions, a width or
// height) is itself representable as a uint32_t without overflow, again for
// uint32_t values M and N. In the contrasting "ii" flavor, the length of the
// closed interval [0, (1<<32) - 1] is 1<<32, which cannot be represented as a
// uint32_t. In Wuffs, because of this potential overflow, the "ie" flavor has
// length / width / height methods, but the "ii" flavor does not.
//
// It is valid for min > max (for range_ii) or for min >= max (for range_ie),
// in which case the range is empty. There are multiple representations of an
// empty range.
typedef struct {
uint32_t min_inclusive;
uint32_t max_inclusive;
} wuffs_base__range_ii_u32;
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);
}
typedef struct {
uint32_t min_inclusive;
uint32_t max_exclusive;
} wuffs_base__range_ie_u32;
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);
}
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_inclusive;
} wuffs_base__range_ii_u64;
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);
}
typedef struct {
uint64_t min_inclusive;
uint64_t max_exclusive;
} wuffs_base__range_ie_u64;
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);
}
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);
}
// 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.
//
// 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_x;
uint32_t min_y;
uint32_t max_x;
uint32_t max_y;
} wuffs_base__rectangle;
uint32_t min_inclusive_x;
uint32_t min_inclusive_y;
uint32_t max_inclusive_x;
uint32_t max_inclusive_y;
} wuffs_base__rect_ii_u32;
static inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {
return r.max_x > r.min_x ? r.max_x - r.min_x : 0;
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);
}
static inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {
return r.max_y > r.min_y ? r.max_y - r.min_y : 0;
// 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.
//
// 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
// fields zero.
//
// 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;
} wuffs_base__rect_ie_u32;
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);
}
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);
}
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);
}
// wuffs_base__slice_u8 is a 1-dimensional buffer.
@@ -497,7 +646,7 @@ typedef struct {
uint32_t loop_count; // 0-based count of the current loop.
wuffs_base__pixel_buffer pixbuf;
// TODO: color spaces.
wuffs_base__rectangle dirty_rect;
wuffs_base__rect_ie_u32 dirty_rect;
wuffs_base__flicks duration;
uint8_t palette[1024];
} private_impl;
@@ -517,7 +666,7 @@ static inline void wuffs_base__image_buffer__initialize(
static inline void wuffs_base__image_buffer__update(
wuffs_base__image_buffer* f,
wuffs_base__rectangle dirty_rect,
wuffs_base__rect_ie_u32 dirty_rect,
wuffs_base__flicks duration,
uint8_t* palette_ptr,
size_t palette_len) {
@@ -553,9 +702,9 @@ static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
// this frame's pixels differs from the previous frame.
static inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(
static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect(
wuffs_base__image_buffer* f) {
return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});
return f ? f->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){0});
}
// wuffs_base__image_buffer__duration returns the amount of time to display