Stub out a new std/crc32 package

This commit is contained in:
Nigel Tao committed 2018-03-25 16:58:23 +11:00
1 parent 26445adcdf
commit 917737ec97
6 files changed
+1134 -2

No files matched your search

+696
View File
@@ -0,0 +1,696 @@
#ifndef WUFFS_CRC32_H
#define WUFFS_CRC32_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 <stdbool.h>
#include <stdint.h>
#include <string.h>
// Wuffs requires a word size of at least 32 bits because it assumes that
// converting a u32 to usize will never overflow. For example, the size of a
// decoded image is often represented, explicitly or implicitly in an image
// file, as a u32, and it is convenient to compare that to a buffer size.
//
// Similarly, the word size is at most 64 bits because it assumes that
// converting a usize to u64 will never overflow.
#if __WORDSIZE < 32
#error "Wuffs requires a word size of at least 32 bits"
#elif __WORDSIZE > 64
#error "Wuffs requires a word size of at most 64 bits"
#endif
// WUFFS_VERSION is the major.minor version number as a uint32. 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 (0x00001)
// ---------------- I/O
// wuffs_base__slice_u8 is a 1-dimensional buffer (a pointer and length).
//
// 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__buf1 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__buf1;
// wuffs_base__limit1 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* 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__limit1 limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
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__buf1* 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__limit1 limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
// ---------------- Images
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 {
uint32_t flags;
uint32_t w;
uint32_t h;
// TODO: color model, including both packed RGBA and planar,
// chroma-subsampled YCbCr.
} private_impl;
} wuffs_base__image_config;
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__valid(
wuffs_base__image_config* c) {
if (!c || !(c->private_impl.flags & 1)) {
return false;
}
uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h);
// TODO: handle things other than 1 byte per pixel.
return wh <= ((uint64_t)SIZE_MAX);
}
static inline uint32_t wuffs_base__image_config__width(
wuffs_base__image_config* c) {
return wuffs_base__image_config__valid(c) ? c->private_impl.w : 0;
}
static inline uint32_t wuffs_base__image_config__height(
wuffs_base__image_config* c) {
return wuffs_base__image_config__valid(c) ? c->private_impl.h : 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__valid(c)) {
uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h);
// TODO: handle things other than 1 byte per pixel.
return (size_t)wh;
}
return 0;
}
static inline void wuffs_base__image_config__initialize(
wuffs_base__image_config* c,
uint32_t width,
uint32_t height,
uint32_t TODO_color_model) {
if (!c) {
return;
}
c->private_impl.flags = 1;
c->private_impl.w = width;
c->private_impl.h = height;
// TODO: color model.
}
#endif // WUFFS_BASE_HEADER_H
// ---------------- Use Declarations
#ifdef __cplusplus
extern "C" {
#endif
// ---------------- Status Codes
// Status codes are int32_t values:
// - the sign bit indicates a non-recoverable status code: an error
// - bits 10-30 hold the packageid: a namespace
// - bits 8-9 are reserved
// - bits 0-7 are a package-namespaced numeric code
//
// Do not manipulate these bits directly. Use the API functions such as
// wuffs_crc32__status__is_error instead.
typedef int32_t wuffs_crc32__status;
#define wuffs_crc32__packageid 810620 // 0x000C5E7C
#define WUFFS_CRC32__STATUS_OK 0 // 0x00000000
#define WUFFS_CRC32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001
#define WUFFS_CRC32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002
#define WUFFS_CRC32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003
#define WUFFS_CRC32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004
#define WUFFS_CRC32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005
#define WUFFS_CRC32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006
#define WUFFS_CRC32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007
#define WUFFS_CRC32__SUSPENSION_SHORT_READ 8 // 0x00000008
#define WUFFS_CRC32__SUSPENSION_SHORT_WRITE 9 // 0x00000009
#define WUFFS_CRC32__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A
#define WUFFS_CRC32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B
#define WUFFS_CRC32__SUSPENSION_END_OF_DATA 12 // 0x0000000C
bool wuffs_crc32__status__is_error(wuffs_crc32__status s);
const char* wuffs_crc32__status__string(wuffs_crc32__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_crc32__ieee__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_crc32__status status;
uint32_t magic;
} private_impl;
} wuffs_crc32__ieee;
// ---------------- Public Initializer Prototypes
// wuffs_crc32__ieee__initialize is an initializer function.
//
// It should be called before any other wuffs_crc32__ieee__* function.
//
// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only.
void wuffs_crc32__ieee__initialize(wuffs_crc32__ieee* self,
uint32_t wuffs_version,
uint32_t for_internal_use_only);
// ---------------- Public Function Prototypes
void wuffs_crc32__ieee__update(wuffs_crc32__ieee* self,
wuffs_base__slice_u8 a_x);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // WUFFS_CRC32_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.
// 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;
#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 (0x3CCB6C71U)
// 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 (0x68602EF1U)
// 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 <stdio.h>
// ---------------- Static Inline Functions
//
// 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.
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 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;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
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__writer1__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__writer1__copy_from_history32__bco is a Bounds Check Optimized
// version of the wuffs_base__writer1__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__writer1__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__writer1__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__writer1__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__writer1__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 reader1 and writer1'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__reader1 wuffs_base__reader1__limit(
wuffs_base__reader1* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 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__reader1__mark(
wuffs_base__reader1* o,
uint8_t* mark) {
o->private_impl.mark = mark;
return ((wuffs_base__empty_struct){});
}
// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* 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_crc32__status__is_error(wuffs_crc32__status s) {
return s < 0;
}
const char* wuffs_crc32__status__strings[0] = {};
const char* wuffs_crc32__status__string(wuffs_crc32__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_crc32__packageid:
a = wuffs_crc32__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_crc32__ieee__initialize(wuffs_crc32__ieee* self,
uint32_t wuffs_version,
uint32_t for_internal_use_only) {
if (!self) {
return;
}
if (wuffs_version != WUFFS_VERSION) {
self->private_impl.status = WUFFS_CRC32__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;
}
// ---------------- Function Implementations
void wuffs_crc32__ieee__update(wuffs_crc32__ieee* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
self->private_impl.status = WUFFS_CRC32__ERROR_INITIALIZER_NOT_CALLED;
}
if (self->private_impl.status < 0) {
return;
}
}
+257
View File
@@ -0,0 +1,257 @@
#ifndef WUFFS_CRC32_H
#define WUFFS_CRC32_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 <stdbool.h>
#include <stdint.h>
#include <string.h>
// Wuffs requires a word size of at least 32 bits because it assumes that
// converting a u32 to usize will never overflow. For example, the size of a
// decoded image is often represented, explicitly or implicitly in an image
// file, as a u32, and it is convenient to compare that to a buffer size.
//
// Similarly, the word size is at most 64 bits because it assumes that
// converting a usize to u64 will never overflow.
#if __WORDSIZE < 32
#error "Wuffs requires a word size of at least 32 bits"
#elif __WORDSIZE > 64
#error "Wuffs requires a word size of at most 64 bits"
#endif
// WUFFS_VERSION is the major.minor version number as a uint32. 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 (0x00001)
// ---------------- I/O
// wuffs_base__slice_u8 is a 1-dimensional buffer (a pointer and length).
//
// 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__buf1 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__buf1;
// wuffs_base__limit1 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* 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__limit1 limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
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__buf1* 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__limit1 limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
// ---------------- Images
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 {
uint32_t flags;
uint32_t w;
uint32_t h;
// TODO: color model, including both packed RGBA and planar,
// chroma-subsampled YCbCr.
} private_impl;
} wuffs_base__image_config;
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__valid(
wuffs_base__image_config* c) {
if (!c || !(c->private_impl.flags & 1)) {
return false;
}
uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h);
// TODO: handle things other than 1 byte per pixel.
return wh <= ((uint64_t)SIZE_MAX);
}
static inline uint32_t wuffs_base__image_config__width(
wuffs_base__image_config* c) {
return wuffs_base__image_config__valid(c) ? c->private_impl.w : 0;
}
static inline uint32_t wuffs_base__image_config__height(
wuffs_base__image_config* c) {
return wuffs_base__image_config__valid(c) ? c->private_impl.h : 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__valid(c)) {
uint64_t wh = ((uint64_t)c->private_impl.w) * ((uint64_t)c->private_impl.h);
// TODO: handle things other than 1 byte per pixel.
return (size_t)wh;
}
return 0;
}
static inline void wuffs_base__image_config__initialize(
wuffs_base__image_config* c,
uint32_t width,
uint32_t height,
uint32_t TODO_color_model) {
if (!c) {
return;
}
c->private_impl.flags = 1;
c->private_impl.w = width;
c->private_impl.h = height;
// TODO: color model.
}
#endif // WUFFS_BASE_HEADER_H
// ---------------- Use Declarations
#ifdef __cplusplus
extern "C" {
#endif
// ---------------- Status Codes
// Status codes are int32_t values:
// - the sign bit indicates a non-recoverable status code: an error
// - bits 10-30 hold the packageid: a namespace
// - bits 8-9 are reserved
// - bits 0-7 are a package-namespaced numeric code
//
// Do not manipulate these bits directly. Use the API functions such as
// wuffs_crc32__status__is_error instead.
typedef int32_t wuffs_crc32__status;
#define wuffs_crc32__packageid 810620 // 0x000C5E7C
#define WUFFS_CRC32__STATUS_OK 0 // 0x00000000
#define WUFFS_CRC32__ERROR_BAD_WUFFS_VERSION -2147483647 // 0x80000001
#define WUFFS_CRC32__ERROR_BAD_RECEIVER -2147483646 // 0x80000002
#define WUFFS_CRC32__ERROR_BAD_ARGUMENT -2147483645 // 0x80000003
#define WUFFS_CRC32__ERROR_INITIALIZER_NOT_CALLED -2147483644 // 0x80000004
#define WUFFS_CRC32__ERROR_INVALID_I_O_OPERATION -2147483643 // 0x80000005
#define WUFFS_CRC32__ERROR_CLOSED_FOR_WRITES -2147483642 // 0x80000006
#define WUFFS_CRC32__ERROR_UNEXPECTED_EOF -2147483641 // 0x80000007
#define WUFFS_CRC32__SUSPENSION_SHORT_READ 8 // 0x00000008
#define WUFFS_CRC32__SUSPENSION_SHORT_WRITE 9 // 0x00000009
#define WUFFS_CRC32__ERROR_CANNOT_RETURN_A_SUSPENSION -2147483638 // 0x8000000A
#define WUFFS_CRC32__ERROR_INVALID_CALL_SEQUENCE -2147483637 // 0x8000000B
#define WUFFS_CRC32__SUSPENSION_END_OF_DATA 12 // 0x0000000C
bool wuffs_crc32__status__is_error(wuffs_crc32__status s);
const char* wuffs_crc32__status__string(wuffs_crc32__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_crc32__ieee__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_crc32__status status;
uint32_t magic;
} private_impl;
} wuffs_crc32__ieee;
// ---------------- Public Initializer Prototypes
// wuffs_crc32__ieee__initialize is an initializer function.
//
// It should be called before any other wuffs_crc32__ieee__* function.
//
// Pass WUFFS_VERSION and 0 for wuffs_version and for_internal_use_only.
void wuffs_crc32__ieee__initialize(wuffs_crc32__ieee* self,
uint32_t wuffs_version,
uint32_t for_internal_use_only);
// ---------------- Public Function Prototypes
void wuffs_crc32__ieee__update(wuffs_crc32__ieee* self,
wuffs_base__slice_u8 a_x);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // WUFFS_CRC32_H
+12
View File
@@ -0,0 +1,12 @@
# CRC32
Crc32 (Cyclic Redundancy Check 32) is a checksum algorithm that hashes byte
sequences to 32 bit values.
The algorithm is based on polynomial division. In theory, a variety of
polynomials can be used. In practice, only two are widely used. The IEEE
polynomial is used by Bzip2, Ethernet (IEEE 802.3), Gzip, MPEG-2, PNG, SATA,
Zip and other formats. The Castagnoli polynomial is used by Btrfs, Ext4, iSCSI,
SCTP and other formats.
TODO: a worked example.
+24
View File
@@ -0,0 +1,24 @@
// Copyright 2018 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.
packageid "crc3"
// TODO: drop the '?' but still generate wuffs_crc32__ieee__initialize?
pub struct ieee?(
)
// TODO: add a ! as this function is impure.
pub func ieee.update(x[] u8)() {
// TODO: implement.
}
+2 -2
View File
@@ -1,9 +1,9 @@
# Zlib
zlib ([RFC 1950](https://www.ietf.org/rfc/rfc1950.txt)) is a thin wrapper
Zlib ([RFC 1950](https://www.ietf.org/rfc/rfc1950.txt)) is a thin wrapper
around raw deflate (RFC 1951). Zlib is similar to gzip (RFC 1952), but with a
different wire format and checksum algorithm.
zlib is used by the ELF executable and PNG image file formats.
Zlib is used by the ELF executable and PNG image file formats.
TODO: a worked example.
+143
View File
@@ -0,0 +1,143 @@
// Copyright 2018 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 crc32.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/crc32.c"
#include "../testlib/testlib.c"
#ifdef WUFFS_MIMIC
#include "../mimiclib/deflate-gzip-zlib.c"
#endif
// ---------------- Golden Tests
golden_test crc32_midsummer_gt = {
.src_filename = "../../data/midsummer.txt", //
};
golden_test crc32_pi_gt = {
.src_filename = "../../data/pi.txt", //
};
// ---------------- CRC32 Tests
void test_wuffs_crc32() {
CHECK_FOCUS(__func__);
// TODO: implement.
}
// ---------------- CRC32 Benches
uint32_t global_wuffs_crc32_unused_u32;
const char* wuffs_bench_crc32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
wuffs_crc32__ieee checksum;
wuffs_crc32__ieee__initialize(&checksum, WUFFS_VERSION, 0);
// TODO: global_wuffs_crc32_unused_u32 =
wuffs_crc32__ieee__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_crc32_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_bench_crc32, tc_src, &crc32_midsummer_gt, 0, 0,
150000);
}
void bench_wuffs_crc32_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_bench_crc32, tc_src, &crc32_pi_gt, 0, 0, 15000);
}
// ---------------- Mimic Benches
#ifdef WUFFS_MIMIC
void bench_mimic_crc32_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_bench_crc32, tc_src, &crc32_midsummer_gt, 0, 0,
150000);
}
void bench_mimic_crc32_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_bench_crc32, tc_src, &crc32_pi_gt, 0, 0, 15000);
}
#endif // WUFFS_MIMIC
// ---------------- Manifest
// The empty comments forces clang-format to place one element per line.
proc tests[] = {
test_wuffs_crc32, //
NULL,
};
// The empty comments forces clang-format to place one element per line.
proc benches[] = {
bench_wuffs_crc32_10k, //
bench_wuffs_crc32_100k, //
#ifdef WUFFS_MIMIC
bench_mimic_crc32_10k, //
bench_mimic_crc32_100k, //
#endif // WUFFS_MIMIC
NULL,
};
int main(int argc, char** argv) {
proc_filename = "std/crc32.c";
return test_main(argc, argv, tests, benches);
}