diff --git a/cmd/wuffs-c/internal/cgen/expr.go b/cmd/wuffs-c/internal/cgen/expr.go index cab4b4c2..d19a4543 100644 --- a/cmd/wuffs-c/internal/cgen/expr.go +++ b/cmd/wuffs-c/internal/cgen/expr.go @@ -317,7 +317,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare // TODO: don't hard-code the class name or this.checksum. class := "wuffs_crc32__ieee" if g.pkgName == "zlib" { - class = "wuffs_zlib__adler32" + class = "wuffs_adler32__hasher" } b.printf("%s__update(&self->private_impl.f_checksum, ", class) a := n.Args()[0].Arg().Value() diff --git a/doc/changelog.md b/doc/changelog.md index 50536e09..a3dec520 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -7,7 +7,7 @@ - Added a `skipgendeps` flag. - Added a `use` keyword. - Added a `yield` keyword. -- Added `std/crc32` and `std/gzip`. +- Added `std/adler32`, `std/crc32` and `std/gzip`. - Spun `std/zlib` out of `std/flate`. - Let the `std/zlib` decoder ignore checksums. - Renamed `std/flate` to `std/deflate`. diff --git a/fuzz/c/std/zlib_fuzzer.cc b/fuzz/c/std/zlib_fuzzer.cc index 8fd556c8..8b5f8878 100644 --- a/fuzz/c/std/zlib_fuzzer.cc +++ b/fuzz/c/std/zlib_fuzzer.cc @@ -35,6 +35,7 @@ It should print "PASS", amongst other information, and exit(0). // If building this program in an environment that doesn't easily accomodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. +#include "../../../gen/c/std/adler32.c" #include "../../../gen/c/std/deflate.c" #include "../../../gen/c/std/zlib.c" #include "../fuzzlib/fuzzlib.cc" diff --git a/gen/c/std/adler32.c b/gen/c/std/adler32.c new file mode 100644 index 00000000..191573d1 --- /dev/null +++ b/gen/c/std/adler32.c @@ -0,0 +1,1610 @@ +#ifndef WUFFS_ADLER32_H +#define WUFFS_ADLER32_H + +// Code generated by wuffs-c. DO NOT EDIT. + +#ifndef WUFFS_BASE_HEADER_H +#define WUFFS_BASE_HEADER_H + +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +// Wuffs assumes that: +// - converting a uint32_t to a size_t will never overflow. +// - converting a size_t to a uint64_t will never overflow. +#if (__WORDSIZE != 32) && (__WORDSIZE != 64) +#error "Wuffs requires a word size of either 32 or 64 bits" +#endif + +// WUFFS_VERSION is the major.minor version number as a uint32_t. The major +// number is the high 16 bits. The minor number is the low 16 bits. +// +// The intention is to bump the version number at least on every API / ABI +// backwards incompatible change. +// +// For now, the API and ABI are simply unstable and can change at any time. +// +// TODO: don't hard code this in base-header.h. +#define WUFFS_VERSION ((uint32_t)0x00001) + +// ---------------- Fundamentals + +// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a +// second. See https://github.com/OculusVR/Flicks +typedef uint64_t wuffs_base__flicks; + +#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) + +// wuffs_base__empty_struct is used when a Wuffs function returns an empty +// struct. In C, if a function f returns void, you can't say "x = f()", but in +// Wuffs, if a function g returns empty, you can say "y = g()". +typedef struct { +} wuffs_base__empty_struct; + +// wuffs_base__slice_u8 is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +typedef struct { + uint8_t* ptr; + size_t len; +} wuffs_base__slice_u8; + +// wuffs_base__table_u8 is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +typedef struct { + uint8_t* ptr; + size_t width; + size_t height; + size_t stride; +} wuffs_base__table_u8; + +// -------- + +static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { + return x < y ? x : y; +} + +static inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) { + return x > y ? x : y; +} + +static inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) { + return x < y ? x : y; +} + +static inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) { + return x > y ? x : y; +} + +static inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) { + return x < y ? x : y; +} + +static inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) { + return x > y ? x : y; +} + +static inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) { + return x < y ? x : y; +} + +static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) { + return x > y ? x : y; +} + +// -------- + +// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms +// are per https://locklessinc.com/articles/sat_arithmetic/ +// +// It is important that the underlying types are unsigned integers, as signed +// integer arithmetic overflow is undefined behavior in C. + +static inline uint8_t wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { + uint8_t res = x + y; + res |= -(res < x); + return res; +} + +static inline uint8_t wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { + uint8_t res = x - y; + res &= -(res <= x); + return res; +} + +static inline uint16_t wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { + uint16_t res = x + y; + res |= -(res < x); + return res; +} + +static inline uint16_t wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { + uint16_t res = x - y; + res &= -(res <= x); + return res; +} + +static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { + 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; +} + +static inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { + *x = wuffs_base__u8__sat_add(*x, y); +} + +static inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { + *x = wuffs_base__u8__sat_sub(*x, y); +} + +static inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { + *x = wuffs_base__u16__sat_add(*x, y); +} + +static inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { + *x = wuffs_base__u16__sat_sub(*x, y); +} + +static inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { + *x = wuffs_base__u32__sat_add(*x, y); +} + +static inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { + *x = wuffs_base__u32__sat_sub(*x, y); +} + +static inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { + *x = wuffs_base__u64__sat_add(*x, y); +} + +static inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { + *x = wuffs_base__u64__sat_sub(*x, y); +} + +// ---------------- Ranges and Rects + +// 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__is_empty( + wuffs_base__range_ii_u32 r) { + return r.min_inclusive > r.max_inclusive; +} + +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); +} + +static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection( + wuffs_base__range_ii_u32 r, + wuffs_base__range_ii_u32 s) { + r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive); + return r; +} + +static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union( + wuffs_base__range_ii_u32 r, + wuffs_base__range_ii_u32 s) { + if (wuffs_base__range_ii_u32__is_empty(r)) { + return s; + } + if (wuffs_base__range_ii_u32__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive); + return r; +} + +// -------- + +typedef struct { + uint32_t min_inclusive; + uint32_t max_exclusive; +} wuffs_base__range_ie_u32; + +static inline bool wuffs_base__range_ie_u32__is_empty( + wuffs_base__range_ie_u32 r) { + return r.min_inclusive >= r.max_exclusive; +} + +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 wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection( + wuffs_base__range_ie_u32 r, + wuffs_base__range_ie_u32 s) { + r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union( + wuffs_base__range_ie_u32 r, + wuffs_base__range_ie_u32 s) { + if (wuffs_base__range_ie_u32__is_empty(r)) { + return s; + } + if (wuffs_base__range_ie_u32__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline uint32_t wuffs_base__range_ie_u32__length( + wuffs_base__range_ie_u32 r) { + return wuffs_base__u32__sat_sub(r.max_exclusive, r.min_inclusive); +} + +// -------- + +typedef struct { + uint64_t min_inclusive; + uint64_t max_inclusive; +} wuffs_base__range_ii_u64; + +static inline bool wuffs_base__range_ii_u64__is_empty( + wuffs_base__range_ii_u64 r) { + return r.min_inclusive > r.max_inclusive; +} + +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); +} + +static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection( + wuffs_base__range_ii_u64 r, + wuffs_base__range_ii_u64 s) { + r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive); + return r; +} + +static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union( + wuffs_base__range_ii_u64 r, + wuffs_base__range_ii_u64 s) { + if (wuffs_base__range_ii_u64__is_empty(r)) { + return s; + } + if (wuffs_base__range_ii_u64__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive); + return r; +} + +// -------- + +typedef struct { + uint64_t min_inclusive; + uint64_t max_exclusive; +} wuffs_base__range_ie_u64; + +static inline bool wuffs_base__range_ie_u64__is_empty( + wuffs_base__range_ie_u64 r) { + return r.min_inclusive >= r.max_exclusive; +} + +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 wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection( + wuffs_base__range_ie_u64 r, + wuffs_base__range_ie_u64 s) { + r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union( + wuffs_base__range_ie_u64 r, + wuffs_base__range_ie_u64 s) { + if (wuffs_base__range_ie_u64__is_empty(r)) { + return s; + } + if (wuffs_base__range_ie_u64__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline uint64_t wuffs_base__range_ie_u64__length( + wuffs_base__range_ie_u64 r) { + return wuffs_base__u64__sat_sub(r.max_exclusive, r.min_inclusive); +} + +// -------- + +// 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_inclusive_x; + uint32_t min_inclusive_y; + uint32_t max_inclusive_x; + uint32_t max_inclusive_y; +} wuffs_base__rect_ii_u32; + +static inline bool wuffs_base__rect_ii_u32__is_empty( + wuffs_base__rect_ii_u32 r) { + return (r.min_inclusive_x > r.max_inclusive_x) || + (r.min_inclusive_y > r.max_inclusive_y); +} + +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 wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersection( + wuffs_base__rect_ii_u32 r, + wuffs_base__rect_ii_u32 s) { + r.min_inclusive_x = + wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y); + r.max_inclusive_x = + wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x); + r.max_inclusive_y = + wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y); + return r; +} + +static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union( + wuffs_base__rect_ii_u32 r, + wuffs_base__rect_ii_u32 s) { + if (wuffs_base__rect_ii_u32__is_empty(r)) { + return s; + } + if (wuffs_base__rect_ii_u32__is_empty(s)) { + return r; + } + r.min_inclusive_x = + wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y); + r.max_inclusive_x = + wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x); + r.max_inclusive_y = + wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y); + return r; +} + +// -------- + +// 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__is_empty( + wuffs_base__rect_ie_u32 r) { + return (r.min_inclusive_x >= r.max_exclusive_x) || + (r.min_inclusive_y >= r.max_exclusive_y); +} + +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 wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersection( + wuffs_base__rect_ie_u32 r, + wuffs_base__rect_ie_u32 s) { + r.min_inclusive_x = + wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y); + r.max_exclusive_x = + wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x); + r.max_exclusive_y = + wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y); + return r; +} + +static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union( + wuffs_base__rect_ie_u32 r, + wuffs_base__rect_ie_u32 s) { + if (wuffs_base__rect_ie_u32__is_empty(r)) { + return s; + } + if (wuffs_base__rect_ie_u32__is_empty(s)) { + return r; + } + r.min_inclusive_x = + wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y); + r.max_exclusive_x = + wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x); + r.max_exclusive_y = + wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y); + return r; +} + +static inline uint32_t wuffs_base__rect_ie_u32__width( + wuffs_base__rect_ie_u32 r) { + return wuffs_base__u32__sat_sub(r.max_exclusive_x, r.min_inclusive_x); +} + +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); +} + +// ---------------- I/O + +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus +// additional indexes into that buffer, plus an opened / closed flag. +// +// A value with all fields NULL or zero is a valid, empty buffer. +typedef struct { + uint8_t* ptr; // Pointer. + size_t len; // Length. + size_t wi; // Write index. Invariant: wi <= len. + size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. +} wuffs_base__io_buffer; + +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: +// its first N bytes. That N can be greater than a buffer's current read or +// write capacity. N decreases naturally over time as bytes are read from or +// written to the stream. +// +// A value with all fields NULL or zero is a valid, unlimited view. +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__io_buffer* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__io_limit limit; + uint8_t* mark; + } private_impl; +} wuffs_base__io_reader; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__io_buffer* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__io_limit limit; + uint8_t* mark; + } private_impl; +} wuffs_base__io_writer; + +// ---------------- Images + +// wuffs_base__pixel_format encodes the format of the bytes that constitute an +// image frame's pixel data. Its bits: +// - bit 31 is reserved. +// - bits 30 .. 28 encodes color (and channel order, in terms of memory). +// - bits 27 .. 26 are reserved. +// - bits 25 .. 24 encodes transparency. +// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB). +// - bit 22 indicates floating point (as opposed to integer). +// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed. +// - bits 19 .. 16 encodes the number of bits (depth) in an index value. +// Zero means direct, not palette-indexed. +// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel. +// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel. +// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel. +// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel. +// +// The bit fields of a wuffs_base__pixel_format are not independent. For +// example, the number of planes should not be greater than the number of +// channels. Similarly, bits 15..4 are unused (and should be zero) if bits +// 31..24 (color and transparency) together imply only 1 channel (gray, no +// alpha) and floating point samples should mean a bit depth of 16, 32 or 64. +// +// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA +// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4 +// channels: cyan, magenta, yellow, black). +// +// For direct formats with N > 1 channels, those channels can be laid out in +// either 1 (packed) or N (planar) planes. For example, RGBA data is usually +// packed, but YUV data is usually planar, due to chroma subsampling (for +// details, see the wuffs_base__pixel_subsampling type). For indexed formats, +// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data +// per index value, and there is only 1 plane (for the index). The distance +// between successive palette elements is always 4 bytes. +// +// The color field is encoded in 3 bits: +// - 0 means A (Alpha). +// - 1 means Y or YA (Gray, Alpha). +// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha). +// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha). +// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha). +// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black). +// - all other values are reserved. +// +// In Wuffs, channels are given in memory order, regardless of endianness, +// since the C type for the pixel data is an array of bytes, not an array of +// uint32_t. For example, packed BGRA with 8 bits per channel means that the +// bytes in memory are always Blue, Green, Red then Alpha. On big-endian +// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB. +// +// When the color field (3 bits) encodes multiple options, the transparency +// field (2 bits) distinguishes them: +// - 0 means fully opaque, no extra channels +// - 1 means fully opaque, one extra channel (X or K, padding or black). +// - 2 means one extra alpha channel, other channels are non-premultiplied. +// - 3 means one extra alpha channel, other channels are premultiplied. +// +// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is +// invalid to combine the zero color (alpha only) with the zero transparency. +// +// Bit depth is encoded in 4 bits: +// - 0 means the channel or index is unused. +// - x means a bit depth of x, for x in the range 1..8. +// - 9 means a bit depth of 10. +// - 10 means a bit depth of 12. +// - 11 means a bit depth of 16. +// - 12 means a bit depth of 24. +// - 13 means a bit depth of 32. +// - 14 means a bit depth of 48. +// - 15 means a bit depth of 64. +// +// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for +// decoding a PNG image - network byte order (also known as big-endian), +// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor +// with alpha (RGBA). In memory order: +// +// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7 +// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo +// +// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no +// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel, +// laid out LSB-first in memory order: +// +// ptr+0........... ptr+1........... +// MSB LSB MSB LSB +// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃ +// +// On little-endian systems (but not big-endian), this Wuffs pixel format value +// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the +// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the +// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the +// other libraries. +// +// Regardless of endianness, this Wuffs pixel format value (0x20000565) +// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565 +// and the Wayland-DRM library's WL_DRM_FORMAT_RGB565. +// +// Different software libraries name their pixel formats (and especially their +// channel order) either according to memory layout or as bits of a native +// integer type like uint32_t. The two conventions differ because of a system's +// endianness. As mentioned earlier, Wuffs pixel formats are always in memory +// order. More detail of other software libraries' naming conventions is in the +// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/ +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_base__pixel_format__num_planes instead. +typedef uint32_t wuffs_base__pixel_format; + +// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid +// wuffs_base__pixel_format values are present. + +#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000) + +#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008) + +#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008) +#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \ + ((wuffs_base__pixel_format)0x12000008) +#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \ + ((wuffs_base__pixel_format)0x13000008) + +#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \ + ((wuffs_base__pixel_format)0x21088888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \ + ((wuffs_base__pixel_format)0x22008888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \ + ((wuffs_base__pixel_format)0x22088888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \ + ((wuffs_base__pixel_format)0x23008888) + +#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \ + ((wuffs_base__pixel_format)0x31088888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \ + ((wuffs_base__pixel_format)0x32008888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \ + ((wuffs_base__pixel_format)0x32088888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \ + ((wuffs_base__pixel_format)0x33008888) + +#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888) +#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888) +#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \ + ((wuffs_base__pixel_format)0x42308888) + +#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888) +#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888) + +static inline bool wuffs_base__pixel_format__is_valid( + wuffs_base__pixel_format f) { + return f != 0; +} + +static inline bool wuffs_base__pixel_format__is_indexed( + wuffs_base__pixel_format f) { + return ((f >> 16) & 0x0F) != 0; +} + +#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 + +static inline uint32_t wuffs_base__pixel_format__num_planes( + wuffs_base__pixel_format f) { + return f ? (((f >> 20) & 0x03) + 1) : 0; +} + +typedef struct { + wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX]; +} wuffs_base__pixel_buffer; + +// -------- + +// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates +// (x, y) to pixel buffer indices (i, j). That mapping can differ for each +// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at +// (planes[p].ptr + (j * planes[p].stride) + i). +// +// For packed pixel formats, the mapping is trivial: i = x and j = y. For +// planar pixel formats, the mapping can differ due to chroma subsampling. For +// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For +// the luma (Y) channel, there is one sample for every pixel, but for the +// chroma (U, V) channels, there is one sample for every two pixels: pairs of +// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In +// general, for a given p: +// - i = (x + bias_x) >> shift_x. +// - j = (y + bias_y) >> shift_y. +// where biases and shifts are in the range 0..3 and 0..2 respectively. +// +// In general, the biases will be zero after decoding an image. However, making +// a sub-image may change the bias, since the (x, y) coordinates are relative +// to the sub-image's top-left origin, but the backing pixel buffers were +// created relative to the original image's origin. +// +// For each plane p, each of those four numbers (biases and shifts) are encoded +// in two bits, which combine to form an 8 bit unsigned integer: +// +// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0) +// +// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc) +// combine to form a wuffs_base__pixel_subsampling value: +// +// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0) +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead. +typedef uint32_t wuffs_base__pixel_subsampling; + +#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE ((wuffs_base__pixel_subsampling)0); + +#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \ + ((wuffs_base__pixel_subsampling)0x000000); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \ + ((wuffs_base__pixel_subsampling)0x010100); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \ + ((wuffs_base__pixel_subsampling)0x101000); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \ + ((wuffs_base__pixel_subsampling)0x111100); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \ + ((wuffs_base__pixel_subsampling)0x202000); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \ + ((wuffs_base__pixel_subsampling)0x212100); + +static inline uint32_t wuffs_base__pixel_subsampling__bias_x( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 6; + return (s >> shift) & 0x03; +} + +static inline uint32_t wuffs_base__pixel_subsampling__shift_x( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 4; + return (s >> shift) & 0x03; +} + +static inline uint32_t wuffs_base__pixel_subsampling__bias_y( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 2; + return (s >> shift) & 0x03; +} + +static inline uint32_t wuffs_base__pixel_subsampling__shift_y( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 0; + return (s >> shift) & 0x03; +} + +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__pixel_format pixfmt; + wuffs_base__pixel_subsampling pixsub; + uint32_t width; + uint32_t height; + uint32_t num_loops; + } private_impl; +} wuffs_base__image_config; + +static inline void wuffs_base__image_config__initialize( + wuffs_base__image_config* c, + wuffs_base__pixel_format pixfmt, + wuffs_base__pixel_subsampling pixsub, + uint32_t width, + uint32_t height, + uint32_t num_loops) { + if (!c) { + return; + } + // TODO: move the check from wuffs_base__image_config__is_valid here. Should + // this function return bool? An error type? + c->private_impl.pixfmt = pixfmt; + c->private_impl.pixsub = pixsub; + c->private_impl.width = width; + c->private_impl.height = height; + c->private_impl.num_loops = num_loops; +} + +static inline void wuffs_base__image_config__invalidate( + wuffs_base__image_config* c) { + if (c) { + *c = ((wuffs_base__image_config){}); + } +} + +static inline bool wuffs_base__image_config__is_valid( + wuffs_base__image_config* c) { + if (!c || !c->private_impl.pixfmt) { + return false; + } + uint64_t wh = + ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); + // TODO: handle things other than 1 byte per pixel. + // + // TODO: move the check to wuffs_base__image_config__initialize. + return wh <= ((uint64_t)SIZE_MAX); +} + +static inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format( + wuffs_base__image_config* c) { + return c ? c->private_impl.pixfmt : 0; +} + +static inline wuffs_base__pixel_subsampling +wuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0; +} + +static inline uint32_t wuffs_base__image_config__width( + wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.width : 0; +} + +static inline uint32_t wuffs_base__image_config__height( + wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.height : 0; +} + +static inline uint32_t wuffs_base__image_config__num_loops( + wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.num_loops : 0; +} + +// TODO: this is the right API for planar (not packed) pixbufs? Should it allow +// decoding into a color model different from the format's intrinsic one? For +// example, decoding a JPEG image straight to RGBA instead of to YCbCr? +static inline size_t wuffs_base__image_config__pixbuf_size( + wuffs_base__image_config* c) { + if (wuffs_base__image_config__is_valid(c)) { + uint64_t wh = + ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); + // TODO: handle things other than 1 byte per pixel. + return (size_t)wh; + } + return 0; +} + +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__image_config config; + uint32_t loop_count; // 0-based count of the current loop. + wuffs_base__pixel_buffer pixbuf; + // TODO: color spaces. + wuffs_base__rect_ie_u32 dirty_rect; + wuffs_base__flicks duration; + uint8_t palette[1024]; + } private_impl; +} wuffs_base__image_buffer; + +static inline void wuffs_base__image_buffer__initialize( + wuffs_base__image_buffer* f, + wuffs_base__image_config config, + wuffs_base__pixel_buffer pixbuf) { + if (!f) { + return; + } + *f = ((wuffs_base__image_buffer){}); + f->private_impl.config = config; + f->private_impl.pixbuf = pixbuf; +} + +static inline void wuffs_base__image_buffer__update( + wuffs_base__image_buffer* f, + wuffs_base__rect_ie_u32 dirty_rect, + wuffs_base__flicks duration, + uint8_t* palette_ptr, + size_t palette_len) { + if (!f) { + return; + } + f->private_impl.dirty_rect = dirty_rect; + f->private_impl.duration = duration; + if (palette_ptr) { + memmove(f->private_impl.palette, palette_ptr, + palette_len <= 1024 ? palette_len : 1024); + } +} + +// wuffs_base__image_buffer__loop returns whether the image decoder should loop +// back to the beginning of the animation, assuming that we've reached the end +// of the encoded stream. If so, it increments f's count of the animation loops +// played so far. +static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) { + if (!f) { + return false; + } + uint32_t n = f->private_impl.config.private_impl.num_loops; + if (n == 0) { + return true; + } + if (f->private_impl.loop_count < n - 1) { + f->private_impl.loop_count++; + return true; + } + return false; +} + +// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of +// this frame's pixels differs from the previous frame. +static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect( + wuffs_base__image_buffer* f) { + 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 +// this frame. Zero means to display forever - a still (non-animated) image. +static inline wuffs_base__flicks wuffs_base__image_buffer__duration( + wuffs_base__image_buffer* f) { + return f ? f->private_impl.duration : 0; +} + +// wuffs_base__image_buffer__palette returns the palette that the pixel data +// can index. The backing array is inside f and has length 1024. +static inline uint8_t* wuffs_base__image_buffer__palette( + wuffs_base__image_buffer* f) { + return f ? f->private_impl.palette : NULL; +} + +#endif // WUFFS_BASE_HEADER_H + + // ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values. Its bits: +// - bit 31 (the sign bit) indicates unrecoverable-ness: an error. +// - bits 30 .. 10 are the packageid: a namespace. +// - bits 9 .. 8 are reserved. +// - bits 7 .. 0 are a package-namespaced numeric code. +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_adler32__status__is_error instead. +typedef int32_t wuffs_adler32__status; + +#define wuffs_adler32__packageid 681002 // 0x000A642A + +#define WUFFS_ADLER32__STATUS_OK 0 // 0x00000000 +#define WUFFS_ADLER32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_ADLER32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_ADLER32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_ADLER32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_ADLER32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_ADLER32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_ADLER32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_ADLER32__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_ADLER32__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_ADLER32__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A +#define WUFFS_ADLER32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_ADLER32__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +bool wuffs_adler32__status__is_error(wuffs_adler32__status s); + +const char* wuffs_adler32__status__string(wuffs_adler32__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. Instead, use the + // wuffs_adler32__hasher__etc functions. + // + // In C++, these fields would be "private", but C does not support that. + // + // It is a struct, not a struct*, so that it can be stack allocated. + struct { + wuffs_adler32__status status; + uint32_t magic; + + uint32_t f_state; + + } private_impl; +} wuffs_adler32__hasher; + +// ---------------- Public Initializer Prototypes + +// wuffs_adler32__hasher__initialize is an initializer function. +// +// It should be called before any other wuffs_adler32__hasher__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +uint32_t wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_ADLER32_H + +// C HEADER ENDS HERE. + +#ifndef WUFFS_BASE_IMPL_H +#define WUFFS_BASE_IMPL_H + +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#define WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(x) (void)(x) + +// WUFFS_BASE__MAGIC is a magic number to check that initializers are called. +// It's not foolproof, given C doesn't automatically zero memory before use, +// but it should catch 99.99% of cases. +// +// Its (non-zero) value is arbitrary, based on md5sum("wuffs"). +#define WUFFS_BASE__MAGIC ((uint32_t)0x3CCB6C71) + +// WUFFS_BASE__ALREADY_ZEROED is passed from a container struct's initializer +// to a containee struct's initializer when the container has already zeroed +// the containee's memory. +// +// Its (non-zero) value is arbitrary, based on md5sum("zeroed"). +#define WUFFS_BASE__ALREADY_ZEROED ((uint32_t)0x68602EF1) + +// Denote intentional fallthroughs for -Wimplicit-fallthrough. +// +// The order matters here. Clang also defines "__GNUC__". +#if defined(__clang__) && __cplusplus >= 201103L +#define WUFFS_BASE__FALLTHROUGH [[clang::fallthrough]] +#elif !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 7) +#define WUFFS_BASE__FALLTHROUGH __attribute__((fallthrough)) +#else +#define WUFFS_BASE__FALLTHROUGH +#endif + +// Use switch cases for coroutine suspension points, similar to the technique +// in https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html +// +// We use trivial macros instead of an explicit assignment and case statement +// so that clang-format doesn't get confused by the unusual "case"s. +#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0 case 0:; +#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT(n) \ + coro_susp_point = n; \ + WUFFS_BASE__FALLTHROUGH; \ + case n:; + +#define WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(n) \ + if (status < 0) { \ + goto exit; \ + } else if (status == 0) { \ + goto ok; \ + } \ + coro_susp_point = n; \ + goto suspend; \ + case n:; + +// Clang also defines "__GNUC__". +#if defined(__GNUC__) +#define WUFFS_BASE__LIKELY(expr) (__builtin_expect(!!(expr), 1)) +#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0)) +#else +#define WUFFS_BASE__LIKELY(expr) (expr) +#define WUFFS_BASE__UNLIKELY(expr) (expr) +#endif + +// Uncomment this #include for printf-debugging. +// #include + +// The helpers below are functions, instead of macros, because their arguments +// can be an expression that we shouldn't evaluate more than once. +// +// They are in base-impl.h and hence copy/pasted into every generated C file, +// instead of being in some "base.c" file, since a design goal is that users of +// the generated C code can often just #include a single .c file, such as +// "gif.c", without having to additionally include or otherwise build and link +// a "base.c" file. +// +// They are static, so that linking multiple wuffs .o files won't complain about +// duplicate function definitions. +// +// They are explicitly marked inline, even if modern compilers don't use the +// inline attribute to guide optimizations such as inlining, to avoid the +// -Wunused-function warning, and we like to compile with -Wall -Werror. + +// ---------------- Fundamentals + +static inline uint16_t wuffs_base__load_u16be(uint8_t* p) { + return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0); +} + +static inline uint16_t wuffs_base__load_u16le(uint8_t* p) { + return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8); +} + +static inline uint32_t wuffs_base__load_u32be(uint8_t* p) { + return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) | + ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0); +} + +static inline uint32_t wuffs_base__load_u32le(uint8_t* p) { + return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) | + ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24); +} + +static inline uint64_t wuffs_base__load_u64be(uint8_t* p) { + return ((uint64_t)(p[0]) << 56) | ((uint64_t)(p[1]) << 48) | + ((uint64_t)(p[2]) << 40) | ((uint64_t)(p[3]) << 32) | + ((uint64_t)(p[4]) << 24) | ((uint64_t)(p[5]) << 16) | + ((uint64_t)(p[6]) << 8) | ((uint64_t)(p[7]) << 0); +} + +static inline uint64_t wuffs_base__load_u64le(uint8_t* p) { + return ((uint64_t)(p[0]) << 0) | ((uint64_t)(p[1]) << 8) | + ((uint64_t)(p[2]) << 16) | ((uint64_t)(p[3]) << 24) | + ((uint64_t)(p[4]) << 32) | ((uint64_t)(p[5]) << 40) | + ((uint64_t)(p[6]) << 48) | ((uint64_t)(p[7]) << 56); +} + +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i( + wuffs_base__slice_u8 s, + uint64_t i) { + if ((i <= SIZE_MAX) && (i <= s.len)) { + return ((wuffs_base__slice_u8){ + .ptr = s.ptr + i, + .len = s.len - i, + }); + } + return ((wuffs_base__slice_u8){}); +} + +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j( + wuffs_base__slice_u8 s, + uint64_t j) { + if ((j <= SIZE_MAX) && (j <= s.len)) { + return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j}); + } + return ((wuffs_base__slice_u8){}); +} + +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij( + wuffs_base__slice_u8 s, + uint64_t i, + uint64_t j) { + if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) { + return ((wuffs_base__slice_u8){ + .ptr = s.ptr + i, + .len = j - i, + }); + } + return ((wuffs_base__slice_u8){}); +} + +// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s. +static inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix( + wuffs_base__slice_u8 s, + uint64_t up_to) { + if ((uint64_t)(s.len) > up_to) { + s.len = up_to; + } + return s; +} + +// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s. +static inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix( + wuffs_base__slice_u8 s, + uint64_t up_to) { + if ((uint64_t)(s.len) > up_to) { + s.ptr += (uint64_t)(s.len) - up_to; + s.len = up_to; + } + return s; +} + +// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr, +// length) where length is the minimum of dst.len and src.len. +// +// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty +// slice) is valid and results in a no-op. +static inline uint64_t wuffs_base__slice_u8__copy_from_slice( + wuffs_base__slice_u8 dst, + wuffs_base__slice_u8 src) { + size_t length = dst.len < src.len ? dst.len : src.len; + if (length > 0) { + memmove(dst.ptr, src.ptr, length); + } + return length; +} + +// ---------------- I/O + +static inline uint32_t wuffs_base__io_writer__copy_from_history32( + uint8_t** ptr_ptr, + uint8_t* start, // May be NULL, meaning an unmarked io_writer. + uint8_t* end, + uint32_t distance, + uint32_t length) { + if (!start || !distance) { + return 0; + } + uint8_t* ptr = *ptr_ptr; + if ((size_t)(ptr - start) < (size_t)(distance)) { + return 0; + } + start = ptr - distance; + size_t n = end - ptr; + if ((size_t)(length) > n) { + length = n; + } else { + n = length; + } + // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that + // is mostly because 3 is the minimum length for the deflate format. This + // function implementation shouldn't overfit to that one format. Perhaps the + // copy_from_history32 Wuffs method should also take an unroll hint argument, + // and the cgen can look if that argument is the constant expression '3'. + // + // See also wuffs_base__io_writer__copy_from_history32__bco below. + // + // Alternatively, or additionally, have a sloppy_copy_from_history32 method + // that copies 8 bytes at a time, possibly writing more than length bytes? + for (; n >= 3; n -= 3) { + *ptr++ = *start++; + *ptr++ = *start++; + *ptr++ = *start++; + } + for (; n; n--) { + *ptr++ = *start++; + } + *ptr_ptr = ptr; + return length; +} + +// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized +// version of the wuffs_base__io_writer__copy_from_history32 function above. +// The caller needs to prove that: +// - start != NULL +// - distance > 0 +// - distance <= (*ptr_ptr - start) +// - length <= (end - *ptr_ptr) +static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco( + uint8_t** ptr_ptr, + uint8_t* start, + uint8_t* end, + uint32_t distance, + uint32_t length) { + uint8_t* ptr = *ptr_ptr; + start = ptr - distance; + uint32_t n = length; + for (; n >= 3; n -= 3) { + *ptr++ = *start++; + *ptr++ = *start++; + *ptr++ = *start++; + } + for (; n; n--) { + *ptr++ = *start++; + } + *ptr_ptr = ptr; + return length; +} + +static inline uint32_t wuffs_base__io_writer__copy_from_reader32( + uint8_t** ptr_wptr, + uint8_t* wend, + uint8_t** ptr_rptr, + uint8_t* rend, + uint32_t length) { + uint8_t* wptr = *ptr_wptr; + size_t n = length; + if (n > wend - wptr) { + n = wend - wptr; + } + uint8_t* rptr = *ptr_rptr; + if (n > rend - rptr) { + n = rend - rptr; + } + if (n > 0) { + memmove(wptr, rptr, n); + *ptr_wptr += n; + *ptr_rptr += n; + } + return n; +} + +static inline uint64_t wuffs_base__io_writer__copy_from_slice( + uint8_t** ptr_wptr, + uint8_t* wend, + wuffs_base__slice_u8 src) { + uint8_t* wptr = *ptr_wptr; + size_t n = src.len; + if (n > wend - wptr) { + n = wend - wptr; + } + if (n > 0) { + memmove(wptr, src.ptr, n); + *ptr_wptr += n; + } + return n; +} + +static inline uint32_t wuffs_base__io_writer__copy_from_slice32( + uint8_t** ptr_wptr, + uint8_t* wend, + wuffs_base__slice_u8 src, + uint32_t length) { + uint8_t* wptr = *ptr_wptr; + size_t n = src.len; + if (n > length) { + n = length; + } + if (n > wend - wptr) { + n = wend - wptr; + } + if (n > 0) { + memmove(wptr, src.ptr, n); + *ptr_wptr += n; + } + return n; +} + +// Note that the *__limit and *__mark methods are private (in base-impl.h) not +// public (in base-header.h). We assume that, at the boundary between user code +// and Wuffs code, the io_reader and io_writer's private_impl fields (including +// limit and mark) are NULL. Otherwise, some internal assumptions break down. +// For example, limits could be represented as pointers, even though +// conceptually they are counts, but that pointer-to-count correspondence +// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine). +// +// Admittedly, some of the Wuffs test code calls these methods, but that test +// code is still Wuffs code, not user code. Other Wuffs test code modifies +// private_impl fields directly. + +static inline wuffs_base__io_reader wuffs_base__io_reader__limit( + wuffs_base__io_reader* o, + uint64_t* ptr_to_len) { + wuffs_base__io_reader ret = *o; + ret.private_impl.limit.ptr_to_len = ptr_to_len; + ret.private_impl.limit.next = &o->private_impl.limit; + return ret; +} + +static inline wuffs_base__empty_struct wuffs_base__io_reader__mark( + wuffs_base__io_reader* o, + uint8_t* mark) { + o->private_impl.mark = mark; + return ((wuffs_base__empty_struct){}); +} + +// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit() + +static inline wuffs_base__empty_struct wuffs_base__io_writer__mark( + wuffs_base__io_writer* o, + uint8_t* mark) { + o->private_impl.mark = mark; + return ((wuffs_base__empty_struct){}); +} + +static const char* wuffs_base__status__strings[13] = { + "ok", + "bad wuffs version", + "bad receiver", + "bad argument", + "initializer not called", + "invalid I/O operation", + "closed for writes", + "unexpected EOF", + "short read", + "short write", + "cannot return a suspension", + "invalid call sequence", + "end of data", +}; + +#endif // WUFFS_BASE_IMPL_H + +// ---------------- Status Codes Implementations + +bool wuffs_adler32__status__is_error(wuffs_adler32__status s) { + return s < 0; +} + +const char* wuffs_adler32__status__strings[0] = {}; + +const char* wuffs_adler32__status__string(wuffs_adler32__status s) { + const char** a = NULL; + uint32_t n = 0; + switch ((s >> 10) & 0x1FFFFF) { + case 0: + a = wuffs_base__status__strings; + n = 13; + break; + case wuffs_adler32__packageid: + a = wuffs_adler32__status__strings; + n = 0; + break; + } + uint32_t i = s & 0xFF; + return i < n ? a[i] : "unknown status"; +} + +// ---------------- Private Consts + +// ---------------- Private Initializer Prototypes + +// ---------------- Private Function Prototypes + +// ---------------- Initializer Implementations + +void wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only) { + if (!self) { + return; + } + if (wuffs_version != WUFFS_VERSION) { + self->private_impl.status = WUFFS_ADLER32__ERROR_BAD_WUFFS_VERSION; + return; + } + if (for_internal_use_only != WUFFS_BASE__ALREADY_ZEROED) { + memset(self, 0, sizeof(*self)); + } + self->private_impl.magic = WUFFS_BASE__MAGIC; + self->private_impl.f_state = 1; +} + +// ---------------- Function Implementations + +uint32_t wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x) { + if (!self) { + return 0; + } + if (self->private_impl.magic != WUFFS_BASE__MAGIC) { + self->private_impl.status = WUFFS_ADLER32__ERROR_INITIALIZER_NOT_CALLED; + } + if (self->private_impl.status < 0) { + return 0; + } + + uint32_t v_s1; + uint32_t v_s2; + wuffs_base__slice_u8 v_remaining; + + v_s1 = ((self->private_impl.f_state) & ((1 << (16)) - 1)); + v_s2 = ((self->private_impl.f_state) >> (32 - (16))); + while (((uint64_t)(a_x.len)) > 0) { + v_remaining = ((wuffs_base__slice_u8){}); + if (((uint64_t)(a_x.len)) > 5552) { + v_remaining = wuffs_base__slice_u8__subslice_i(a_x, 5552); + a_x = wuffs_base__slice_u8__subslice_j(a_x, 5552); + } + { + wuffs_base__slice_u8 i_slice_p = a_x; + uint8_t* v_p = i_slice_p.ptr; + uint8_t* i_end0_p = i_slice_p.ptr + (i_slice_p.len / 8) * 8; + while (v_p < i_end0_p) { + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + } + uint8_t* i_end1_p = i_slice_p.ptr + i_slice_p.len; + while (v_p < i_end1_p) { + v_s1 += ((uint32_t)(*v_p)); + v_s2 += v_s1; + v_p++; + } + } + v_s1 %= 65521; + v_s2 %= 65521; + a_x = v_remaining; + } + self->private_impl.f_state = (((v_s2 & 65535) << 16) | (v_s1 & 65535)); + return self->private_impl.f_state; +} diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 78cb964d..6b842d98 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -1023,10 +1023,10 @@ static inline uint8_t* wuffs_base__image_buffer__palette( // ---------------- Use Declarations - // ---------------- BEGIN USE "std/deflate" + // ---------------- BEGIN USE "std/adler32" -#ifndef WUFFS_DEFLATE_H -#define WUFFS_DEFLATE_H +#ifndef WUFFS_ADLER32_H +#define WUFFS_ADLER32_H // Code generated by wuffs-c. DO NOT EDIT. @@ -1038,6 +1038,97 @@ extern "C" { // ---------------- Status Codes +// Status codes are int32_t values. Its bits: +// - bit 31 (the sign bit) indicates unrecoverable-ness: an error. +// - bits 30 .. 10 are the packageid: a namespace. +// - bits 9 .. 8 are reserved. +// - bits 7 .. 0 are a package-namespaced numeric code. +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_adler32__status__is_error instead. +typedef int32_t wuffs_adler32__status; + +#define wuffs_adler32__packageid 681002 // 0x000A642A + +#define WUFFS_ADLER32__STATUS_OK 0 // 0x00000000 +#define WUFFS_ADLER32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_ADLER32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_ADLER32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_ADLER32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_ADLER32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_ADLER32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_ADLER32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_ADLER32__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_ADLER32__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_ADLER32__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A +#define WUFFS_ADLER32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_ADLER32__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +bool wuffs_adler32__status__is_error(wuffs_adler32__status s); + +const char* wuffs_adler32__status__string(wuffs_adler32__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. Instead, use the + // wuffs_adler32__hasher__etc functions. + // + // In C++, these fields would be "private", but C does not support that. + // + // It is a struct, not a struct*, so that it can be stack allocated. + struct { + wuffs_adler32__status status; + uint32_t magic; + + uint32_t f_state; + + } private_impl; +} wuffs_adler32__hasher; + +// ---------------- Public Initializer Prototypes + +// wuffs_adler32__hasher__initialize is an initializer function. +// +// It should be called before any other wuffs_adler32__hasher__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +uint32_t wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_ADLER32_H + +// ---------------- END USE "std/adler32" + +// ---------------- BEGIN USE "std/deflate" + +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H + +// Code generated by wuffs-c. DO NOT EDIT. + +// ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + // Status codes are int32_t values. Its bits: // - bit 31 (the sign bit) indicates unrecoverable-ness: an error. // - bits 30 .. 10 are the packageid: a namespace. @@ -1254,23 +1345,6 @@ const char* wuffs_zlib__status__string(wuffs_zlib__status s); // ---------------- Structs -typedef struct { - // Do not access the private_impl's fields directly. There is no API/ABI - // compatibility or safety guarantee if you do so. Instead, use the - // wuffs_zlib__adler32__etc functions. - // - // In C++, these fields would be "private", but C does not support that. - // - // It is a struct, not a struct*, so that it can be stack allocated. - struct { - wuffs_zlib__status status; - uint32_t magic; - - uint32_t f_state; - - } private_impl; -} wuffs_zlib__adler32; - typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. Instead, use the @@ -1284,7 +1358,7 @@ typedef struct { uint32_t magic; wuffs_deflate__decoder f_flate; - wuffs_zlib__adler32 f_checksum; + wuffs_adler32__hasher f_checksum; bool f_ignore_checksum; struct { @@ -1735,6 +1809,8 @@ const char* wuffs_zlib__status__string(wuffs_zlib__status s) { a = wuffs_zlib__status__strings; n = 5; break; + case wuffs_adler32__packageid: + return wuffs_adler32__status__string(s); case wuffs_deflate__packageid: return wuffs_deflate__status__string(s); } @@ -1746,34 +1822,10 @@ const char* wuffs_zlib__status__string(wuffs_zlib__status s) { // ---------------- Private Initializer Prototypes -void wuffs_zlib__adler32__initialize(wuffs_zlib__adler32* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only); - // ---------------- Private Function Prototypes -static uint32_t wuffs_zlib__adler32__update(wuffs_zlib__adler32* self, - wuffs_base__slice_u8 a_x); - // ---------------- Initializer Implementations -void wuffs_zlib__adler32__initialize(wuffs_zlib__adler32* self, - uint32_t wuffs_version, - uint32_t for_internal_use_only) { - if (!self) { - return; - } - if (wuffs_version != WUFFS_VERSION) { - self->private_impl.status = WUFFS_ZLIB__ERROR_BAD_WUFFS_VERSION; - return; - } - if (for_internal_use_only != WUFFS_BASE__ALREADY_ZEROED) { - memset(self, 0, sizeof(*self)); - } - self->private_impl.magic = WUFFS_BASE__MAGIC; - self->private_impl.f_state = 1; -} - void wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, uint32_t wuffs_version, uint32_t for_internal_use_only) { @@ -1790,71 +1842,12 @@ void wuffs_zlib__decoder__initialize(wuffs_zlib__decoder* self, self->private_impl.magic = WUFFS_BASE__MAGIC; wuffs_deflate__decoder__initialize(&self->private_impl.f_flate, WUFFS_VERSION, WUFFS_BASE__ALREADY_ZEROED); - wuffs_zlib__adler32__initialize(&self->private_impl.f_checksum, WUFFS_VERSION, - WUFFS_BASE__ALREADY_ZEROED); + wuffs_adler32__hasher__initialize(&self->private_impl.f_checksum, + WUFFS_VERSION, WUFFS_BASE__ALREADY_ZEROED); } // ---------------- Function Implementations -static uint32_t wuffs_zlib__adler32__update(wuffs_zlib__adler32* self, - wuffs_base__slice_u8 a_x) { - uint32_t v_s1; - uint32_t v_s2; - wuffs_base__slice_u8 v_remaining; - - v_s1 = ((self->private_impl.f_state) & ((1 << (16)) - 1)); - v_s2 = ((self->private_impl.f_state) >> (32 - (16))); - while (((uint64_t)(a_x.len)) > 0) { - v_remaining = ((wuffs_base__slice_u8){}); - if (((uint64_t)(a_x.len)) > 5552) { - v_remaining = wuffs_base__slice_u8__subslice_i(a_x, 5552); - a_x = wuffs_base__slice_u8__subslice_j(a_x, 5552); - } - { - wuffs_base__slice_u8 i_slice_p = a_x; - uint8_t* v_p = i_slice_p.ptr; - uint8_t* i_end0_p = i_slice_p.ptr + (i_slice_p.len / 8) * 8; - while (v_p < i_end0_p) { - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - } - uint8_t* i_end1_p = i_slice_p.ptr + i_slice_p.len; - while (v_p < i_end1_p) { - v_s1 += ((uint32_t)(*v_p)); - v_s2 += v_s1; - v_p++; - } - } - v_s1 %= 65521; - v_s2 %= 65521; - a_x = v_remaining; - } - self->private_impl.f_state = (((v_s2 & 65535) << 16) | (v_s1 & 65535)); - return self->private_impl.f_state; -} - void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) { if (!self) { @@ -2014,7 +2007,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self, v_z = t_2; } if (!self->private_impl.f_ignore_checksum) { - v_checksum_got = wuffs_zlib__adler32__update( + v_checksum_got = wuffs_adler32__hasher__update( &self->private_impl.f_checksum, ((wuffs_base__slice_u8){ .ptr = a_dst.private_impl.mark, diff --git a/gen/h/std/adler32.h b/gen/h/std/adler32.h new file mode 100644 index 00000000..06ee5348 --- /dev/null +++ b/gen/h/std/adler32.h @@ -0,0 +1,1104 @@ +#ifndef WUFFS_ADLER32_H +#define WUFFS_ADLER32_H + +// Code generated by wuffs-c. DO NOT EDIT. + +#ifndef WUFFS_BASE_HEADER_H +#define WUFFS_BASE_HEADER_H + +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +// Wuffs assumes that: +// - converting a uint32_t to a size_t will never overflow. +// - converting a size_t to a uint64_t will never overflow. +#if (__WORDSIZE != 32) && (__WORDSIZE != 64) +#error "Wuffs requires a word size of either 32 or 64 bits" +#endif + +// WUFFS_VERSION is the major.minor version number as a uint32_t. The major +// number is the high 16 bits. The minor number is the low 16 bits. +// +// The intention is to bump the version number at least on every API / ABI +// backwards incompatible change. +// +// For now, the API and ABI are simply unstable and can change at any time. +// +// TODO: don't hard code this in base-header.h. +#define WUFFS_VERSION ((uint32_t)0x00001) + +// ---------------- Fundamentals + +// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a +// second. See https://github.com/OculusVR/Flicks +typedef uint64_t wuffs_base__flicks; + +#define WUFFS_BASE__FLICKS_PER_SECOND ((uint64_t)705600000) + +// wuffs_base__empty_struct is used when a Wuffs function returns an empty +// struct. In C, if a function f returns void, you can't say "x = f()", but in +// Wuffs, if a function g returns empty, you can say "y = g()". +typedef struct { +} wuffs_base__empty_struct; + +// wuffs_base__slice_u8 is a 1-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty slice. +typedef struct { + uint8_t* ptr; + size_t len; +} wuffs_base__slice_u8; + +// wuffs_base__table_u8 is a 2-dimensional buffer. +// +// A value with all fields NULL or zero is a valid, empty table. +typedef struct { + uint8_t* ptr; + size_t width; + size_t height; + size_t stride; +} wuffs_base__table_u8; + +// -------- + +static inline uint8_t wuffs_base__u8__min(uint8_t x, uint8_t y) { + return x < y ? x : y; +} + +static inline uint8_t wuffs_base__u8__max(uint8_t x, uint8_t y) { + return x > y ? x : y; +} + +static inline uint16_t wuffs_base__u16__min(uint16_t x, uint16_t y) { + return x < y ? x : y; +} + +static inline uint16_t wuffs_base__u16__max(uint16_t x, uint16_t y) { + return x > y ? x : y; +} + +static inline uint32_t wuffs_base__u32__min(uint32_t x, uint32_t y) { + return x < y ? x : y; +} + +static inline uint32_t wuffs_base__u32__max(uint32_t x, uint32_t y) { + return x > y ? x : y; +} + +static inline uint64_t wuffs_base__u64__min(uint64_t x, uint64_t y) { + return x < y ? x : y; +} + +static inline uint64_t wuffs_base__u64__max(uint64_t x, uint64_t y) { + return x > y ? x : y; +} + +// -------- + +// Saturating arithmetic (sat_add, sat_sub) branchless bit-twiddling algorithms +// are per https://locklessinc.com/articles/sat_arithmetic/ +// +// It is important that the underlying types are unsigned integers, as signed +// integer arithmetic overflow is undefined behavior in C. + +static inline uint8_t wuffs_base__u8__sat_add(uint8_t x, uint8_t y) { + uint8_t res = x + y; + res |= -(res < x); + return res; +} + +static inline uint8_t wuffs_base__u8__sat_sub(uint8_t x, uint8_t y) { + uint8_t res = x - y; + res &= -(res <= x); + return res; +} + +static inline uint16_t wuffs_base__u16__sat_add(uint16_t x, uint16_t y) { + uint16_t res = x + y; + res |= -(res < x); + return res; +} + +static inline uint16_t wuffs_base__u16__sat_sub(uint16_t x, uint16_t y) { + uint16_t res = x - y; + res &= -(res <= x); + return res; +} + +static inline uint32_t wuffs_base__u32__sat_add(uint32_t x, uint32_t y) { + 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; +} + +static inline void wuffs_base__u8__sat_add_indirect(uint8_t* x, uint8_t y) { + *x = wuffs_base__u8__sat_add(*x, y); +} + +static inline void wuffs_base__u8__sat_sub_indirect(uint8_t* x, uint8_t y) { + *x = wuffs_base__u8__sat_sub(*x, y); +} + +static inline void wuffs_base__u16__sat_add_indirect(uint16_t* x, uint16_t y) { + *x = wuffs_base__u16__sat_add(*x, y); +} + +static inline void wuffs_base__u16__sat_sub_indirect(uint16_t* x, uint16_t y) { + *x = wuffs_base__u16__sat_sub(*x, y); +} + +static inline void wuffs_base__u32__sat_add_indirect(uint32_t* x, uint32_t y) { + *x = wuffs_base__u32__sat_add(*x, y); +} + +static inline void wuffs_base__u32__sat_sub_indirect(uint32_t* x, uint32_t y) { + *x = wuffs_base__u32__sat_sub(*x, y); +} + +static inline void wuffs_base__u64__sat_add_indirect(uint64_t* x, uint64_t y) { + *x = wuffs_base__u64__sat_add(*x, y); +} + +static inline void wuffs_base__u64__sat_sub_indirect(uint64_t* x, uint64_t y) { + *x = wuffs_base__u64__sat_sub(*x, y); +} + +// ---------------- Ranges and Rects + +// 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__is_empty( + wuffs_base__range_ii_u32 r) { + return r.min_inclusive > r.max_inclusive; +} + +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); +} + +static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__intersection( + wuffs_base__range_ii_u32 r, + wuffs_base__range_ii_u32 s) { + r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u32__min(r.max_inclusive, s.max_inclusive); + return r; +} + +static inline wuffs_base__range_ii_u32 wuffs_base__range_ii_u32__union( + wuffs_base__range_ii_u32 r, + wuffs_base__range_ii_u32 s) { + if (wuffs_base__range_ii_u32__is_empty(r)) { + return s; + } + if (wuffs_base__range_ii_u32__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u32__max(r.max_inclusive, s.max_inclusive); + return r; +} + +// -------- + +typedef struct { + uint32_t min_inclusive; + uint32_t max_exclusive; +} wuffs_base__range_ie_u32; + +static inline bool wuffs_base__range_ie_u32__is_empty( + wuffs_base__range_ie_u32 r) { + return r.min_inclusive >= r.max_exclusive; +} + +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 wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__intersection( + wuffs_base__range_ie_u32 r, + wuffs_base__range_ie_u32 s) { + r.min_inclusive = wuffs_base__u32__max(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u32__min(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline wuffs_base__range_ie_u32 wuffs_base__range_ie_u32__union( + wuffs_base__range_ie_u32 r, + wuffs_base__range_ie_u32 s) { + if (wuffs_base__range_ie_u32__is_empty(r)) { + return s; + } + if (wuffs_base__range_ie_u32__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u32__min(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u32__max(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline uint32_t wuffs_base__range_ie_u32__length( + wuffs_base__range_ie_u32 r) { + return wuffs_base__u32__sat_sub(r.max_exclusive, r.min_inclusive); +} + +// -------- + +typedef struct { + uint64_t min_inclusive; + uint64_t max_inclusive; +} wuffs_base__range_ii_u64; + +static inline bool wuffs_base__range_ii_u64__is_empty( + wuffs_base__range_ii_u64 r) { + return r.min_inclusive > r.max_inclusive; +} + +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); +} + +static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__intersection( + wuffs_base__range_ii_u64 r, + wuffs_base__range_ii_u64 s) { + r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u64__min(r.max_inclusive, s.max_inclusive); + return r; +} + +static inline wuffs_base__range_ii_u64 wuffs_base__range_ii_u64__union( + wuffs_base__range_ii_u64 r, + wuffs_base__range_ii_u64 s) { + if (wuffs_base__range_ii_u64__is_empty(r)) { + return s; + } + if (wuffs_base__range_ii_u64__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive); + r.max_inclusive = wuffs_base__u64__max(r.max_inclusive, s.max_inclusive); + return r; +} + +// -------- + +typedef struct { + uint64_t min_inclusive; + uint64_t max_exclusive; +} wuffs_base__range_ie_u64; + +static inline bool wuffs_base__range_ie_u64__is_empty( + wuffs_base__range_ie_u64 r) { + return r.min_inclusive >= r.max_exclusive; +} + +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 wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__intersection( + wuffs_base__range_ie_u64 r, + wuffs_base__range_ie_u64 s) { + r.min_inclusive = wuffs_base__u64__max(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u64__min(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline wuffs_base__range_ie_u64 wuffs_base__range_ie_u64__union( + wuffs_base__range_ie_u64 r, + wuffs_base__range_ie_u64 s) { + if (wuffs_base__range_ie_u64__is_empty(r)) { + return s; + } + if (wuffs_base__range_ie_u64__is_empty(s)) { + return r; + } + r.min_inclusive = wuffs_base__u64__min(r.min_inclusive, s.min_inclusive); + r.max_exclusive = wuffs_base__u64__max(r.max_exclusive, s.max_exclusive); + return r; +} + +static inline uint64_t wuffs_base__range_ie_u64__length( + wuffs_base__range_ie_u64 r) { + return wuffs_base__u64__sat_sub(r.max_exclusive, r.min_inclusive); +} + +// -------- + +// 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_inclusive_x; + uint32_t min_inclusive_y; + uint32_t max_inclusive_x; + uint32_t max_inclusive_y; +} wuffs_base__rect_ii_u32; + +static inline bool wuffs_base__rect_ii_u32__is_empty( + wuffs_base__rect_ii_u32 r) { + return (r.min_inclusive_x > r.max_inclusive_x) || + (r.min_inclusive_y > r.max_inclusive_y); +} + +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 wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__intersection( + wuffs_base__rect_ii_u32 r, + wuffs_base__rect_ii_u32 s) { + r.min_inclusive_x = + wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y); + r.max_inclusive_x = + wuffs_base__u32__min(r.max_inclusive_x, s.max_inclusive_x); + r.max_inclusive_y = + wuffs_base__u32__min(r.max_inclusive_y, s.max_inclusive_y); + return r; +} + +static inline wuffs_base__rect_ii_u32 wuffs_base__rect_ii_u32__union( + wuffs_base__rect_ii_u32 r, + wuffs_base__rect_ii_u32 s) { + if (wuffs_base__rect_ii_u32__is_empty(r)) { + return s; + } + if (wuffs_base__rect_ii_u32__is_empty(s)) { + return r; + } + r.min_inclusive_x = + wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y); + r.max_inclusive_x = + wuffs_base__u32__max(r.max_inclusive_x, s.max_inclusive_x); + r.max_inclusive_y = + wuffs_base__u32__max(r.max_inclusive_y, s.max_inclusive_y); + return r; +} + +// -------- + +// 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__is_empty( + wuffs_base__rect_ie_u32 r) { + return (r.min_inclusive_x >= r.max_exclusive_x) || + (r.min_inclusive_y >= r.max_exclusive_y); +} + +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 wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__intersection( + wuffs_base__rect_ie_u32 r, + wuffs_base__rect_ie_u32 s) { + r.min_inclusive_x = + wuffs_base__u32__max(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__max(r.min_inclusive_y, s.min_inclusive_y); + r.max_exclusive_x = + wuffs_base__u32__min(r.max_exclusive_x, s.max_exclusive_x); + r.max_exclusive_y = + wuffs_base__u32__min(r.max_exclusive_y, s.max_exclusive_y); + return r; +} + +static inline wuffs_base__rect_ie_u32 wuffs_base__rect_ie_u32__union( + wuffs_base__rect_ie_u32 r, + wuffs_base__rect_ie_u32 s) { + if (wuffs_base__rect_ie_u32__is_empty(r)) { + return s; + } + if (wuffs_base__rect_ie_u32__is_empty(s)) { + return r; + } + r.min_inclusive_x = + wuffs_base__u32__min(r.min_inclusive_x, s.min_inclusive_x); + r.min_inclusive_y = + wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y); + r.max_exclusive_x = + wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x); + r.max_exclusive_y = + wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y); + return r; +} + +static inline uint32_t wuffs_base__rect_ie_u32__width( + wuffs_base__rect_ie_u32 r) { + return wuffs_base__u32__sat_sub(r.max_exclusive_x, r.min_inclusive_x); +} + +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); +} + +// ---------------- I/O + +// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus +// additional indexes into that buffer, plus an opened / closed flag. +// +// A value with all fields NULL or zero is a valid, empty buffer. +typedef struct { + uint8_t* ptr; // Pointer. + size_t len; // Length. + size_t wi; // Write index. Invariant: wi <= len. + size_t ri; // Read index. Invariant: ri <= wi. + bool closed; // No further writes are expected. +} wuffs_base__io_buffer; + +// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream: +// its first N bytes. That N can be greater than a buffer's current read or +// write capacity. N decreases naturally over time as bytes are read from or +// written to the stream. +// +// A value with all fields NULL or zero is a valid, unlimited view. +typedef struct wuffs_base__io_limit { + uint64_t* ptr_to_len; // Pointer to N. + struct wuffs_base__io_limit* next; // Linked list of limits. +} wuffs_base__io_limit; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__io_buffer* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__io_limit limit; + uint8_t* mark; + } private_impl; +} wuffs_base__io_reader; + +typedef struct { + // TODO: move buf into private_impl? As it is, it looks like users can modify + // the buf field to point to a different buffer, which can turn the limit and + // mark fields into dangling pointers. + wuffs_base__io_buffer* buf; + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__io_limit limit; + uint8_t* mark; + } private_impl; +} wuffs_base__io_writer; + +// ---------------- Images + +// wuffs_base__pixel_format encodes the format of the bytes that constitute an +// image frame's pixel data. Its bits: +// - bit 31 is reserved. +// - bits 30 .. 28 encodes color (and channel order, in terms of memory). +// - bits 27 .. 26 are reserved. +// - bits 25 .. 24 encodes transparency. +// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB). +// - bit 22 indicates floating point (as opposed to integer). +// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed. +// - bits 19 .. 16 encodes the number of bits (depth) in an index value. +// Zero means direct, not palette-indexed. +// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel. +// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel. +// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel. +// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel. +// +// The bit fields of a wuffs_base__pixel_format are not independent. For +// example, the number of planes should not be greater than the number of +// channels. Similarly, bits 15..4 are unused (and should be zero) if bits +// 31..24 (color and transparency) together imply only 1 channel (gray, no +// alpha) and floating point samples should mean a bit depth of 16, 32 or 64. +// +// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA +// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4 +// channels: cyan, magenta, yellow, black). +// +// For direct formats with N > 1 channels, those channels can be laid out in +// either 1 (packed) or N (planar) planes. For example, RGBA data is usually +// packed, but YUV data is usually planar, due to chroma subsampling (for +// details, see the wuffs_base__pixel_subsampling type). For indexed formats, +// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data +// per index value, and there is only 1 plane (for the index). The distance +// between successive palette elements is always 4 bytes. +// +// The color field is encoded in 3 bits: +// - 0 means A (Alpha). +// - 1 means Y or YA (Gray, Alpha). +// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha). +// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha). +// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha). +// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black). +// - all other values are reserved. +// +// In Wuffs, channels are given in memory order, regardless of endianness, +// since the C type for the pixel data is an array of bytes, not an array of +// uint32_t. For example, packed BGRA with 8 bits per channel means that the +// bytes in memory are always Blue, Green, Red then Alpha. On big-endian +// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB. +// +// When the color field (3 bits) encodes multiple options, the transparency +// field (2 bits) distinguishes them: +// - 0 means fully opaque, no extra channels +// - 1 means fully opaque, one extra channel (X or K, padding or black). +// - 2 means one extra alpha channel, other channels are non-premultiplied. +// - 3 means one extra alpha channel, other channels are premultiplied. +// +// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is +// invalid to combine the zero color (alpha only) with the zero transparency. +// +// Bit depth is encoded in 4 bits: +// - 0 means the channel or index is unused. +// - x means a bit depth of x, for x in the range 1..8. +// - 9 means a bit depth of 10. +// - 10 means a bit depth of 12. +// - 11 means a bit depth of 16. +// - 12 means a bit depth of 24. +// - 13 means a bit depth of 32. +// - 14 means a bit depth of 48. +// - 15 means a bit depth of 64. +// +// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for +// decoding a PNG image - network byte order (also known as big-endian), +// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor +// with alpha (RGBA). In memory order: +// +// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7 +// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo +// +// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no +// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel, +// laid out LSB-first in memory order: +// +// ptr+0........... ptr+1........... +// MSB LSB MSB LSB +// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃ +// +// On little-endian systems (but not big-endian), this Wuffs pixel format value +// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the +// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the +// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the +// other libraries. +// +// Regardless of endianness, this Wuffs pixel format value (0x20000565) +// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565 +// and the Wayland-DRM library's WL_DRM_FORMAT_RGB565. +// +// Different software libraries name their pixel formats (and especially their +// channel order) either according to memory layout or as bits of a native +// integer type like uint32_t. The two conventions differ because of a system's +// endianness. As mentioned earlier, Wuffs pixel formats are always in memory +// order. More detail of other software libraries' naming conventions is in the +// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/ +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_base__pixel_format__num_planes instead. +typedef uint32_t wuffs_base__pixel_format; + +// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid +// wuffs_base__pixel_format values are present. + +#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000) + +#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008) + +#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008) +#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \ + ((wuffs_base__pixel_format)0x12000008) +#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \ + ((wuffs_base__pixel_format)0x13000008) + +#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \ + ((wuffs_base__pixel_format)0x21088888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \ + ((wuffs_base__pixel_format)0x22008888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \ + ((wuffs_base__pixel_format)0x22088888) +#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \ + ((wuffs_base__pixel_format)0x23008888) + +#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \ + ((wuffs_base__pixel_format)0x31088888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \ + ((wuffs_base__pixel_format)0x32008888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \ + ((wuffs_base__pixel_format)0x32088888) +#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \ + ((wuffs_base__pixel_format)0x33008888) + +#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888) +#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888) +#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \ + ((wuffs_base__pixel_format)0x42308888) + +#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888) +#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888) + +static inline bool wuffs_base__pixel_format__is_valid( + wuffs_base__pixel_format f) { + return f != 0; +} + +static inline bool wuffs_base__pixel_format__is_indexed( + wuffs_base__pixel_format f) { + return ((f >> 16) & 0x0F) != 0; +} + +#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 + +static inline uint32_t wuffs_base__pixel_format__num_planes( + wuffs_base__pixel_format f) { + return f ? (((f >> 20) & 0x03) + 1) : 0; +} + +typedef struct { + wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX]; +} wuffs_base__pixel_buffer; + +// -------- + +// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates +// (x, y) to pixel buffer indices (i, j). That mapping can differ for each +// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at +// (planes[p].ptr + (j * planes[p].stride) + i). +// +// For packed pixel formats, the mapping is trivial: i = x and j = y. For +// planar pixel formats, the mapping can differ due to chroma subsampling. For +// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For +// the luma (Y) channel, there is one sample for every pixel, but for the +// chroma (U, V) channels, there is one sample for every two pixels: pairs of +// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In +// general, for a given p: +// - i = (x + bias_x) >> shift_x. +// - j = (y + bias_y) >> shift_y. +// where biases and shifts are in the range 0..3 and 0..2 respectively. +// +// In general, the biases will be zero after decoding an image. However, making +// a sub-image may change the bias, since the (x, y) coordinates are relative +// to the sub-image's top-left origin, but the backing pixel buffers were +// created relative to the original image's origin. +// +// For each plane p, each of those four numbers (biases and shifts) are encoded +// in two bits, which combine to form an 8 bit unsigned integer: +// +// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0) +// +// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc) +// combine to form a wuffs_base__pixel_subsampling value: +// +// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0) +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead. +typedef uint32_t wuffs_base__pixel_subsampling; + +#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE ((wuffs_base__pixel_subsampling)0); + +#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \ + ((wuffs_base__pixel_subsampling)0x000000); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \ + ((wuffs_base__pixel_subsampling)0x010100); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \ + ((wuffs_base__pixel_subsampling)0x101000); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \ + ((wuffs_base__pixel_subsampling)0x111100); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \ + ((wuffs_base__pixel_subsampling)0x202000); +#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \ + ((wuffs_base__pixel_subsampling)0x212100); + +static inline uint32_t wuffs_base__pixel_subsampling__bias_x( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 6; + return (s >> shift) & 0x03; +} + +static inline uint32_t wuffs_base__pixel_subsampling__shift_x( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 4; + return (s >> shift) & 0x03; +} + +static inline uint32_t wuffs_base__pixel_subsampling__bias_y( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 2; + return (s >> shift) & 0x03; +} + +static inline uint32_t wuffs_base__pixel_subsampling__shift_y( + wuffs_base__pixel_subsampling s, + uint32_t plane) { + uint32_t shift = ((plane & 0x03) * 8) + 0; + return (s >> shift) & 0x03; +} + +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__pixel_format pixfmt; + wuffs_base__pixel_subsampling pixsub; + uint32_t width; + uint32_t height; + uint32_t num_loops; + } private_impl; +} wuffs_base__image_config; + +static inline void wuffs_base__image_config__initialize( + wuffs_base__image_config* c, + wuffs_base__pixel_format pixfmt, + wuffs_base__pixel_subsampling pixsub, + uint32_t width, + uint32_t height, + uint32_t num_loops) { + if (!c) { + return; + } + // TODO: move the check from wuffs_base__image_config__is_valid here. Should + // this function return bool? An error type? + c->private_impl.pixfmt = pixfmt; + c->private_impl.pixsub = pixsub; + c->private_impl.width = width; + c->private_impl.height = height; + c->private_impl.num_loops = num_loops; +} + +static inline void wuffs_base__image_config__invalidate( + wuffs_base__image_config* c) { + if (c) { + *c = ((wuffs_base__image_config){}); + } +} + +static inline bool wuffs_base__image_config__is_valid( + wuffs_base__image_config* c) { + if (!c || !c->private_impl.pixfmt) { + return false; + } + uint64_t wh = + ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); + // TODO: handle things other than 1 byte per pixel. + // + // TODO: move the check to wuffs_base__image_config__initialize. + return wh <= ((uint64_t)SIZE_MAX); +} + +static inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format( + wuffs_base__image_config* c) { + return c ? c->private_impl.pixfmt : 0; +} + +static inline wuffs_base__pixel_subsampling +wuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0; +} + +static inline uint32_t wuffs_base__image_config__width( + wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.width : 0; +} + +static inline uint32_t wuffs_base__image_config__height( + wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.height : 0; +} + +static inline uint32_t wuffs_base__image_config__num_loops( + wuffs_base__image_config* c) { + return wuffs_base__image_config__is_valid(c) ? c->private_impl.num_loops : 0; +} + +// TODO: this is the right API for planar (not packed) pixbufs? Should it allow +// decoding into a color model different from the format's intrinsic one? For +// example, decoding a JPEG image straight to RGBA instead of to YCbCr? +static inline size_t wuffs_base__image_config__pixbuf_size( + wuffs_base__image_config* c) { + if (wuffs_base__image_config__is_valid(c)) { + uint64_t wh = + ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height); + // TODO: handle things other than 1 byte per pixel. + return (size_t)wh; + } + return 0; +} + +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + wuffs_base__image_config config; + uint32_t loop_count; // 0-based count of the current loop. + wuffs_base__pixel_buffer pixbuf; + // TODO: color spaces. + wuffs_base__rect_ie_u32 dirty_rect; + wuffs_base__flicks duration; + uint8_t palette[1024]; + } private_impl; +} wuffs_base__image_buffer; + +static inline void wuffs_base__image_buffer__initialize( + wuffs_base__image_buffer* f, + wuffs_base__image_config config, + wuffs_base__pixel_buffer pixbuf) { + if (!f) { + return; + } + *f = ((wuffs_base__image_buffer){}); + f->private_impl.config = config; + f->private_impl.pixbuf = pixbuf; +} + +static inline void wuffs_base__image_buffer__update( + wuffs_base__image_buffer* f, + wuffs_base__rect_ie_u32 dirty_rect, + wuffs_base__flicks duration, + uint8_t* palette_ptr, + size_t palette_len) { + if (!f) { + return; + } + f->private_impl.dirty_rect = dirty_rect; + f->private_impl.duration = duration; + if (palette_ptr) { + memmove(f->private_impl.palette, palette_ptr, + palette_len <= 1024 ? palette_len : 1024); + } +} + +// wuffs_base__image_buffer__loop returns whether the image decoder should loop +// back to the beginning of the animation, assuming that we've reached the end +// of the encoded stream. If so, it increments f's count of the animation loops +// played so far. +static inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) { + if (!f) { + return false; + } + uint32_t n = f->private_impl.config.private_impl.num_loops; + if (n == 0) { + return true; + } + if (f->private_impl.loop_count < n - 1) { + f->private_impl.loop_count++; + return true; + } + return false; +} + +// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of +// this frame's pixels differs from the previous frame. +static inline wuffs_base__rect_ie_u32 wuffs_base__image_buffer__dirty_rect( + wuffs_base__image_buffer* f) { + 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 +// this frame. Zero means to display forever - a still (non-animated) image. +static inline wuffs_base__flicks wuffs_base__image_buffer__duration( + wuffs_base__image_buffer* f) { + return f ? f->private_impl.duration : 0; +} + +// wuffs_base__image_buffer__palette returns the palette that the pixel data +// can index. The backing array is inside f and has length 1024. +static inline uint8_t* wuffs_base__image_buffer__palette( + wuffs_base__image_buffer* f) { + return f ? f->private_impl.palette : NULL; +} + +#endif // WUFFS_BASE_HEADER_H + + // ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + +// Status codes are int32_t values. Its bits: +// - bit 31 (the sign bit) indicates unrecoverable-ness: an error. +// - bits 30 .. 10 are the packageid: a namespace. +// - bits 9 .. 8 are reserved. +// - bits 7 .. 0 are a package-namespaced numeric code. +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_adler32__status__is_error instead. +typedef int32_t wuffs_adler32__status; + +#define wuffs_adler32__packageid 681002 // 0x000A642A + +#define WUFFS_ADLER32__STATUS_OK 0 // 0x00000000 +#define WUFFS_ADLER32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_ADLER32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_ADLER32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_ADLER32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_ADLER32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_ADLER32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_ADLER32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_ADLER32__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_ADLER32__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_ADLER32__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A +#define WUFFS_ADLER32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_ADLER32__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +bool wuffs_adler32__status__is_error(wuffs_adler32__status s); + +const char* wuffs_adler32__status__string(wuffs_adler32__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. Instead, use the + // wuffs_adler32__hasher__etc functions. + // + // In C++, these fields would be "private", but C does not support that. + // + // It is a struct, not a struct*, so that it can be stack allocated. + struct { + wuffs_adler32__status status; + uint32_t magic; + + uint32_t f_state; + + } private_impl; +} wuffs_adler32__hasher; + +// ---------------- Public Initializer Prototypes + +// wuffs_adler32__hasher__initialize is an initializer function. +// +// It should be called before any other wuffs_adler32__hasher__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +uint32_t wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_ADLER32_H diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h index 360fc35d..d143453a 100644 --- a/gen/h/std/zlib.h +++ b/gen/h/std/zlib.h @@ -1023,10 +1023,10 @@ static inline uint8_t* wuffs_base__image_buffer__palette( // ---------------- Use Declarations - // ---------------- BEGIN USE "std/deflate" + // ---------------- BEGIN USE "std/adler32" -#ifndef WUFFS_DEFLATE_H -#define WUFFS_DEFLATE_H +#ifndef WUFFS_ADLER32_H +#define WUFFS_ADLER32_H // Code generated by wuffs-c. DO NOT EDIT. @@ -1038,6 +1038,97 @@ extern "C" { // ---------------- Status Codes +// Status codes are int32_t values. Its bits: +// - bit 31 (the sign bit) indicates unrecoverable-ness: an error. +// - bits 30 .. 10 are the packageid: a namespace. +// - bits 9 .. 8 are reserved. +// - bits 7 .. 0 are a package-namespaced numeric code. +// +// Do not manipulate these bits directly; they are private implementation +// details. Use methods such as wuffs_adler32__status__is_error instead. +typedef int32_t wuffs_adler32__status; + +#define wuffs_adler32__packageid 681002 // 0x000A642A + +#define WUFFS_ADLER32__STATUS_OK 0 // 0x00000000 +#define WUFFS_ADLER32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001 +#define WUFFS_ADLER32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002 +#define WUFFS_ADLER32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003 +#define WUFFS_ADLER32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004 +#define WUFFS_ADLER32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005 +#define WUFFS_ADLER32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006 +#define WUFFS_ADLER32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007 +#define WUFFS_ADLER32__SUSPENSION_SHORT_READ 8 // 0x00000008 +#define WUFFS_ADLER32__SUSPENSION_SHORT_WRITE 9 // 0x00000009 +#define WUFFS_ADLER32__ERROR_CANNOT_RETURN_A_SUSPENSION \ + -2147483638 // 0x8000000A +#define WUFFS_ADLER32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B +#define WUFFS_ADLER32__SUSPENSION_END_OF_DATA 12 // 0x0000000C + +bool wuffs_adler32__status__is_error(wuffs_adler32__status s); + +const char* wuffs_adler32__status__string(wuffs_adler32__status s); + +// ---------------- Public Consts + +// ---------------- Structs + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. Instead, use the + // wuffs_adler32__hasher__etc functions. + // + // In C++, these fields would be "private", but C does not support that. + // + // It is a struct, not a struct*, so that it can be stack allocated. + struct { + wuffs_adler32__status status; + uint32_t magic; + + uint32_t f_state; + + } private_impl; +} wuffs_adler32__hasher; + +// ---------------- Public Initializer Prototypes + +// wuffs_adler32__hasher__initialize is an initializer function. +// +// It should be called before any other wuffs_adler32__hasher__* function. +// +// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only. +void wuffs_adler32__hasher__initialize(wuffs_adler32__hasher* self, + uint32_t wuffs_version, + uint32_t for_internal_use_only); + +// ---------------- Public Function Prototypes + +uint32_t wuffs_adler32__hasher__update(wuffs_adler32__hasher* self, + wuffs_base__slice_u8 a_x); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // WUFFS_ADLER32_H + +// ---------------- END USE "std/adler32" + +// ---------------- BEGIN USE "std/deflate" + +#ifndef WUFFS_DEFLATE_H +#define WUFFS_DEFLATE_H + +// Code generated by wuffs-c. DO NOT EDIT. + +// ---------------- Use Declarations + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Status Codes + // Status codes are int32_t values. Its bits: // - bit 31 (the sign bit) indicates unrecoverable-ness: an error. // - bits 30 .. 10 are the packageid: a namespace. @@ -1254,23 +1345,6 @@ const char* wuffs_zlib__status__string(wuffs_zlib__status s); // ---------------- Structs -typedef struct { - // Do not access the private_impl's fields directly. There is no API/ABI - // compatibility or safety guarantee if you do so. Instead, use the - // wuffs_zlib__adler32__etc functions. - // - // In C++, these fields would be "private", but C does not support that. - // - // It is a struct, not a struct*, so that it can be stack allocated. - struct { - wuffs_zlib__status status; - uint32_t magic; - - uint32_t f_state; - - } private_impl; -} wuffs_zlib__adler32; - typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. Instead, use the @@ -1284,7 +1358,7 @@ typedef struct { uint32_t magic; wuffs_deflate__decoder f_flate; - wuffs_zlib__adler32 f_checksum; + wuffs_adler32__hasher f_checksum; bool f_ignore_checksum; struct { diff --git a/script/bench-c-deflate-fragmentation.c b/script/bench-c-deflate-fragmentation.c index cdeda25d..adb40ce5 100644 --- a/script/bench-c-deflate-fragmentation.c +++ b/script/bench-c-deflate-fragmentation.c @@ -61,6 +61,7 @@ // If building this program in an environment that doesn't easily accomodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. +#include "../gen/c/std/adler32.c" #include "../gen/c/std/deflate.c" #include "../gen/c/std/zlib.c" diff --git a/std/adler32/README.md b/std/adler32/README.md new file mode 100644 index 00000000..72a7eb1f --- /dev/null +++ b/std/adler32/README.md @@ -0,0 +1,5 @@ +# Adler32 + +Adler32 is a checksum algorithm that hashes byte sequences to 32 bit values. + +TODO: a worked example. diff --git a/std/zlib/common_adler32.wuffs b/std/adler32/common_adler32.wuffs similarity index 87% rename from std/zlib/common_adler32.wuffs rename to std/adler32/common_adler32.wuffs index 28fccd53..b6258e01 100644 --- a/std/zlib/common_adler32.wuffs +++ b/std/adler32/common_adler32.wuffs @@ -12,13 +12,15 @@ // See the License for the specific language governing permissions and // limitations under the License. -// TODO: drop the '?' but still generate wuffs_zlib__adler32__initialize? -pri struct adler32?( +packageid "adl3" + +// TODO: drop the '?' but still generate wuffs_adler32__hasher__initialize? +pub struct hasher?( state base.u32 = 1, ) // TODO: add a ! as this function is impure. -pri func adler32.update(x slice base.u8)(checksum base.u32) { +pub func hasher.update(x slice base.u8)(checksum base.u32) { // The Adler-32 checksum's magic 65521 and 5552 numbers are discussed in // RFC 1950. diff --git a/std/zlib/decode_zlib.wuffs b/std/zlib/decode_zlib.wuffs index 773a634a..8f7dbb6a 100644 --- a/std/zlib/decode_zlib.wuffs +++ b/std/zlib/decode_zlib.wuffs @@ -14,6 +14,7 @@ packageid "zlib" +use "std/adler32" use "std/deflate" pub error "checksum mismatch" @@ -25,7 +26,7 @@ pub error "TODO: unsupported zlib preset dictionary" pub struct decoder?( flate deflate.decoder, - checksum adler32, + checksum adler32.hasher, ignore_checksum base.bool, ) diff --git a/test/c/std/adler32.c b/test/c/std/adler32.c new file mode 100644 index 00000000..4bc06048 --- /dev/null +++ b/test/c/std/adler32.c @@ -0,0 +1,263 @@ +// Copyright 2017 The Wuffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* +This test program is typically run indirectly, by the "wuffs test" or "wuffs +bench" commands. These commands take an optional "-mimic" flag to check that +Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as +giflib for GIF, libpng for PNG, etc. + +To manually run this test: + +for cc in clang gcc; do + $cc -std=c99 -Wall -Werror adler32.c && ./a.out + rm -f a.out +done + +Each edition should print "PASS", amongst other information, and exit(0). + +Add the "wuffs mimic cflags" (everything after the colon below) to the C +compiler flags (after the .c file) to run the mimic tests. + +To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace +the first "./a.out" with "./a.out -bench". Combine these changes with the +"wuffs mimic cflags" to run the mimic benchmarks. +*/ + +// !! wuffs mimic cflags: -DWUFFS_MIMIC -lz + +// If building this program in an environment that doesn't easily accomodate +// relative includes, you can use the script/inline-c-relative-includes.go +// program to generate a stand-alone C file. +#include "../../../gen/c/std/adler32.c" +#include "../testlib/testlib.c" +#ifdef WUFFS_MIMIC +#include "../mimiclib/deflate-gzip-zlib.c" +#endif + +// ---------------- Golden Tests + +golden_test adler32_midsummer_gt = { + .src_filename = "../../data/midsummer.txt", // +}; + +golden_test adler32_pi_gt = { + .src_filename = "../../data/pi.txt", // +}; + +// ---------------- Adler32 Tests + +void test_wuffs_adler32_golden() { + CHECK_FOCUS(__func__); + + struct { + const char* filename; + // The want values are determined by script/checksum.go. + uint32_t want; + } test_cases[] = { + { + .filename = "../../data/hat.bmp", + .want = 0x3D26D034, + }, + { + .filename = "../../data/hat.gif", + .want = 0x2A5EB144, + }, + { + .filename = "../../data/hat.jpeg", + .want = 0x3A503B1A, + }, + { + .filename = "../../data/hat.lossless.webp", + .want = 0xD059D427, + }, + { + .filename = "../../data/hat.lossy.webp", + .want = 0xF1BB258D, + }, + { + .filename = "../../data/hat.png", + .want = 0xDFC6C9C6, + }, + { + .filename = "../../data/hat.tiff", + .want = 0xBDC011E9, + }, + }; + + int i; + for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { + wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + if (!read_file(&src, test_cases[i].filename)) { + return; + } + + int j; + for (j = 0; j < 2; j++) { + wuffs_adler32__hasher checksum; + wuffs_adler32__hasher__initialize(&checksum, WUFFS_VERSION, 0); + + uint32_t got; + size_t num_fragments = 0; + size_t num_bytes = 0; + do { + wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){ + .ptr = src.ptr + num_bytes, + .len = src.wi - num_bytes, + }); + size_t limit = 101 + 103 * num_fragments; + if ((j > 0) && (data.len > limit)) { + data.len = limit; + } + got = wuffs_adler32__hasher__update(&checksum, data); + num_fragments++; + num_bytes += data.len; + } while (num_bytes < src.wi); + + if (got != test_cases[i].want) { + FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 + ", want 0x%08" PRIX32 "\n", + i, j, test_cases[i].filename, got, test_cases[i].want); + return; + } + } + } +} + +void test_wuffs_adler32_pi() { + CHECK_FOCUS(__func__); + + const char* digits = + "3.1415926535897932384626433832795028841971693993751058209749445"; + if (strlen(digits) != 63) { + FAIL("strlen(digits): got %d, want 63", (int)(strlen(digits))); + return; + } + + // The want values are determined by script/checksum.go. + // + // wants[i] is the checksum of the first i bytes of the digits string. + uint32_t wants[64] = { + 0x00000001, 0x00340034, 0x00960062, 0x01290093, 0x01F000C7, 0x02E800F8, + 0x0415012D, 0x057B0166, 0x07130198, 0x08E101CE, 0x0AE40203, 0x0D1A0236, + 0x0F85026B, 0x122802A3, 0x150402DC, 0x18170313, 0x1B63034C, 0x1EE2037F, + 0x229303B1, 0x267703E4, 0x2A93041C, 0x2EE30450, 0x33690486, 0x382104B8, + 0x3D0F04EE, 0x42310522, 0x47860555, 0x4D0E0588, 0x52CE05C0, 0x58C105F3, + 0x5EE60625, 0x6542065C, 0x6BD70695, 0x72A106CA, 0x799B06FA, 0x80C7072C, + 0x882B0764, 0x8FC7079C, 0x979707D0, 0x9F980801, 0xA7D2083A, 0xB0430871, + 0xB8E508A2, 0xC1BD08D8, 0xCACE0911, 0xD4120944, 0xDD8F097D, 0xE74509B6, + 0xF12E09E9, 0xFB4E0A20, 0x05B20A55, 0x10380A86, 0x1AEE0AB6, 0x25D90AEB, + 0x30FC0B23, 0x3C510B55, 0x47D60B85, 0x53940BBE, 0x5F890BF5, 0x6BB20C29, + 0x78140C62, 0x84AA0C96, 0x91740CCA, 0x9E730CFF, + }; + + int i; + for (i = 0; i < 64; i++) { + wuffs_adler32__hasher checksum; + wuffs_adler32__hasher__initialize(&checksum, WUFFS_VERSION, 0); + uint32_t got = + wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){ + .ptr = (uint8_t*)(digits), + .len = i, + })); + if (got != wants[i]) { + FAIL("i=%d: got 0x%08" PRIX32 ", want 0x%08" PRIX32 "\n", i, got, + wants[i]); + return; + } + } +} + +// ---------------- Adler32 Benches + +uint32_t global_wuffs_adler32_unused_u32; + +const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, + wuffs_base__io_buffer* src, + uint64_t wlimit, + uint64_t rlimit) { + // TODO: don't ignore wlimit and rlimit. + wuffs_adler32__hasher checksum; + wuffs_adler32__hasher__initialize(&checksum, WUFFS_VERSION, 0); + global_wuffs_adler32_unused_u32 = + wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){ + .ptr = src->ptr + src->ri, + .len = src->wi - src->ri, + })); + src->ri = src->wi; + return NULL; +} + +void bench_wuffs_adler32_10k() { + CHECK_FOCUS(__func__); + do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, + 150000); +} + +void bench_wuffs_adler32_100k() { + CHECK_FOCUS(__func__); + do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); +} + + // ---------------- Mimic Benches + +#ifdef WUFFS_MIMIC + +void bench_mimic_adler32_10k() { + CHECK_FOCUS(__func__); + do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, + 150000); +} + +void bench_mimic_adler32_100k() { + CHECK_FOCUS(__func__); + do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); +} + +#endif // WUFFS_MIMIC + +// ---------------- Manifest + +// Note that the adler32 mimic tests and benches don't work with +// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB. + +// The empty comments forces clang-format to place one element per line. +proc tests[] = { + + test_wuffs_adler32_golden, // + test_wuffs_adler32_pi, // + + NULL, +}; + +// The empty comments forces clang-format to place one element per line. +proc benches[] = { + + bench_wuffs_adler32_10k, // + bench_wuffs_adler32_100k, // + +#ifdef WUFFS_MIMIC + + bench_mimic_adler32_10k, // + bench_mimic_adler32_100k, // + +#endif // WUFFS_MIMIC + + NULL, +}; + +int main(int argc, char** argv) { + proc_filename = "std/adler32.c"; + return test_main(argc, argv, tests, benches); +} diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index 925774e1..8436c433 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -40,6 +40,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // If building this program in an environment that doesn't easily accomodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. +#include "../../../gen/c/std/adler32.c" #include "../../../gen/c/std/deflate.c" #include "../../../gen/c/std/zlib.c" #include "../testlib/testlib.c" @@ -49,14 +50,6 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the // ---------------- Golden Tests -golden_test adler32_midsummer_gt = { - .src_filename = "../../data/midsummer.txt", // -}; - -golden_test adler32_pi_gt = { - .src_filename = "../../data/pi.txt", // -}; - golden_test zlib_midsummer_gt = { .want_filename = "../../data/midsummer.txt", // .src_filename = "../../data/midsummer.txt.zlib", // @@ -82,129 +75,6 @@ void test_basic_status_used_package() { } } -// ---------------- Adler32 Tests - -void test_wuffs_adler32_golden() { - CHECK_FOCUS(__func__); - - struct { - const char* filename; - // The want values are determined by script/checksum.go. - uint32_t want; - } test_cases[] = { - { - .filename = "../../data/hat.bmp", - .want = 0x3D26D034, - }, - { - .filename = "../../data/hat.gif", - .want = 0x2A5EB144, - }, - { - .filename = "../../data/hat.jpeg", - .want = 0x3A503B1A, - }, - { - .filename = "../../data/hat.lossless.webp", - .want = 0xD059D427, - }, - { - .filename = "../../data/hat.lossy.webp", - .want = 0xF1BB258D, - }, - { - .filename = "../../data/hat.png", - .want = 0xDFC6C9C6, - }, - { - .filename = "../../data/hat.tiff", - .want = 0xBDC011E9, - }, - }; - - int i; - for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { - wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; - if (!read_file(&src, test_cases[i].filename)) { - return; - } - - int j; - for (j = 0; j < 2; j++) { - wuffs_zlib__adler32 checksum; - wuffs_zlib__adler32__initialize(&checksum, WUFFS_VERSION, 0); - - uint32_t got; - size_t num_fragments = 0; - size_t num_bytes = 0; - do { - wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){ - .ptr = src.ptr + num_bytes, - .len = src.wi - num_bytes, - }); - size_t limit = 101 + 103 * num_fragments; - if ((j > 0) && (data.len > limit)) { - data.len = limit; - } - got = wuffs_zlib__adler32__update(&checksum, data); - num_fragments++; - num_bytes += data.len; - } while (num_bytes < src.wi); - - if (got != test_cases[i].want) { - FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32 - ", want 0x%08" PRIX32 "\n", - i, j, test_cases[i].filename, got, test_cases[i].want); - return; - } - } - } -} - -void test_wuffs_adler32_pi() { - CHECK_FOCUS(__func__); - - const char* digits = - "3.1415926535897932384626433832795028841971693993751058209749445"; - if (strlen(digits) != 63) { - FAIL("strlen(digits): got %d, want 63", (int)(strlen(digits))); - return; - } - - // The want values are determined by script/checksum.go. - // - // wants[i] is the checksum of the first i bytes of the digits string. - uint32_t wants[64] = { - 0x00000001, 0x00340034, 0x00960062, 0x01290093, 0x01F000C7, 0x02E800F8, - 0x0415012D, 0x057B0166, 0x07130198, 0x08E101CE, 0x0AE40203, 0x0D1A0236, - 0x0F85026B, 0x122802A3, 0x150402DC, 0x18170313, 0x1B63034C, 0x1EE2037F, - 0x229303B1, 0x267703E4, 0x2A93041C, 0x2EE30450, 0x33690486, 0x382104B8, - 0x3D0F04EE, 0x42310522, 0x47860555, 0x4D0E0588, 0x52CE05C0, 0x58C105F3, - 0x5EE60625, 0x6542065C, 0x6BD70695, 0x72A106CA, 0x799B06FA, 0x80C7072C, - 0x882B0764, 0x8FC7079C, 0x979707D0, 0x9F980801, 0xA7D2083A, 0xB0430871, - 0xB8E508A2, 0xC1BD08D8, 0xCACE0911, 0xD4120944, 0xDD8F097D, 0xE74509B6, - 0xF12E09E9, 0xFB4E0A20, 0x05B20A55, 0x10380A86, 0x1AEE0AB6, 0x25D90AEB, - 0x30FC0B23, 0x3C510B55, 0x47D60B85, 0x53940BBE, 0x5F890BF5, 0x6BB20C29, - 0x78140C62, 0x84AA0C96, 0x91740CCA, 0x9E730CFF, - }; - - int i; - for (i = 0; i < 64; i++) { - wuffs_zlib__adler32 checksum; - wuffs_zlib__adler32__initialize(&checksum, WUFFS_VERSION, 0); - uint32_t got = - wuffs_zlib__adler32__update(&checksum, ((wuffs_base__slice_u8){ - .ptr = (uint8_t*)(digits), - .len = i, - })); - if (got != wants[i]) { - FAIL("i=%d: got 0x%08" PRIX32 ", want 0x%08" PRIX32 "\n", i, got, - wants[i]); - return; - } - } -} - // ---------------- Zlib Tests const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, @@ -345,37 +215,6 @@ void test_mimic_zlib_decode_pi() { #endif // WUFFS_MIMIC -// ---------------- Adler32 Benches - -uint32_t global_wuffs_zlib_unused_u32; - -const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst, - wuffs_base__io_buffer* src, - uint64_t wlimit, - uint64_t rlimit) { - // TODO: don't ignore wlimit and rlimit. - wuffs_zlib__adler32 checksum; - wuffs_zlib__adler32__initialize(&checksum, WUFFS_VERSION, 0); - global_wuffs_zlib_unused_u32 = - wuffs_zlib__adler32__update(&checksum, ((wuffs_base__slice_u8){ - .ptr = src->ptr + src->ri, - .len = src->wi - src->ri, - })); - src->ri = src->wi; - return NULL; -} - -void bench_wuffs_adler32_10k() { - CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, - 150000); -} - -void bench_wuffs_adler32_100k() { - CHECK_FOCUS(__func__); - do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); -} - // ---------------- Zlib Benches void bench_wuffs_zlib_decode_10k() { @@ -393,17 +232,6 @@ void bench_wuffs_zlib_decode_100k() { #ifdef WUFFS_MIMIC -void bench_mimic_adler32_10k() { - CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0, - 150000); -} - -void bench_mimic_adler32_100k() { - CHECK_FOCUS(__func__); - do_bench_io_buffers(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000); -} - void bench_mimic_zlib_decode_10k() { CHECK_FOCUS(__func__); do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0, @@ -419,9 +247,6 @@ void bench_mimic_zlib_decode_100k() { // ---------------- Manifest -// Note that the adler32 mimic tests and benches don't work with -// WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB. - // The empty comments forces clang-format to place one element per line. proc tests[] = { @@ -430,9 +255,6 @@ proc tests[] = { // other place. test_basic_status_used_package, // - test_wuffs_adler32_golden, // - test_wuffs_adler32_pi, // - test_wuffs_zlib_checksum_ignore, // test_wuffs_zlib_checksum_verify_bad, // test_wuffs_zlib_checksum_verify_good, // @@ -452,17 +274,11 @@ proc tests[] = { // The empty comments forces clang-format to place one element per line. proc benches[] = { - bench_wuffs_adler32_10k, // - bench_wuffs_adler32_100k, // - bench_wuffs_zlib_decode_10k, // bench_wuffs_zlib_decode_100k, // #ifdef WUFFS_MIMIC - bench_mimic_adler32_10k, // - bench_mimic_adler32_100k, // - bench_mimic_zlib_decode_10k, // bench_mimic_zlib_decode_100k, //