Rename buf1, reader1, etc to io_buffer, io_reader

Also remove the unused Buf1, Buf2 and Usize tokens.
This commit is contained in:
Nigel Tao committed 2018-04-05 20:49:48 +10:00
1 parent 82a48796c8
commit 97aab37462
46 files changed
+823 -847

No files matched your search

+13 -15
View File
@@ -96,9 +96,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -108,44 +106,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
+19 -19
View File
@@ -186,9 +186,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
static inline uint32_t wuffs_base__io_writer__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
uint8_t* start, // May be NULL, meaning an unmarked io_writer.
uint8_t* end,
uint32_t distance,
uint32_t length) {
@@ -212,7 +212,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
// 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.
// 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?
@@ -228,14 +228,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
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:
// 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__writer1__copy_from_history32__bco(
static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
@@ -256,7 +256,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_reader32(
static inline uint32_t wuffs_base__io_writer__copy_from_reader32(
uint8_t** ptr_wptr,
uint8_t* wend,
uint8_t** ptr_rptr,
@@ -279,7 +279,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32(
return n;
}
static inline uint64_t wuffs_base__writer1__copy_from_slice(
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src) {
@@ -295,7 +295,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__writer1__copy_from_slice32(
static inline uint32_t wuffs_base__io_writer__copy_from_slice32(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src,
@@ -317,7 +317,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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
// 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
@@ -327,26 +327,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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,
static inline wuffs_base__io_reader wuffs_base__io_reader__limit(
wuffs_base__io_reader* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 ret = *o;
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__reader1__mark(
wuffs_base__reader1* o,
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__writer1 wuffs_base__writer1__limit()
// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* o,
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){});
+25 -25
View File
@@ -20,25 +20,25 @@ const baseHeader = "" +
"#ifndef WUFFS_BASE_HEADER_H\n#define WUFFS_BASE_HEADER_H\n\n// Copyright 2017 The Wuffs Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include <stdbool.h>\n#include <stdint.h>\n#include <string.h>\n\n// Wuffs requires a word size of at least 32 bits because it assumes that\n// converting a u32 to usize will never overflow. For example, the size of a\n// decoded image is often represented, explicitly or implicitly in an image\n// file, as a u32, and it is convenient to compare that to a buffer size.\n//\n// Si" +
"milarly, the word size is at most 64 bits because it assumes that\n// converting a usize to u64 will never overflow.\n#if __WORDSIZE < 32\n#error \"Wuffs requires a word size of at least 32 bits\"\n#elif __WORDSIZE > 64\n#error \"Wuffs requires a word size of at most 64 bits\"\n#endif\n\n// WUFFS_VERSION is the major.minor version number as a uint32. The major\n// number is the high 16 bits. The minor number is the low 16 bits.\n//\n// The intention is to bump the version number at least on every API / ABI\n// backwards incompatible change.\n//\n// For now, the API and ABI are simply unstable and can change at any time.\n//\n// TODO: don't hard code this in base-header.h.\n#define WUFFS_VERSION 0x00001\n\n// ---------------- Fundamentals\n\n// Flicks are a unit of time. One flick (frame-tick) is 1 / 705_600_000 of a\n// second. See https://github.com/OculusVR/Flicks\ntypedef uint64_t wuffs_base__flicks;\n\n#define WUFFS_BASE__FLICKS_PER_SECOND 705600000ULL\n\n// wuffs_base__rectangle is a rectangle on the integer grid. It contains all\n// p" +
"oints (x, y) such that ((min_x <= x) && (x < max_x)) and likewise for y. It\n// is therefore empty if min_x >= max_x. There are multiple representations of\n// an empty rectangle.\n//\n// A value with all fields zero is a valid, empty rectangle.\n//\n// The X and Y axes increase right and down.\ntypedef struct {\n uint32_t min_x;\n uint32_t min_y;\n uint32_t max_x;\n uint32_t max_y;\n} wuffs_base__rectangle;\n\nstatic inline uint32_t wuffs_base__rectangle__width(wuffs_base__rectangle r) {\n return r.max_x > r.min_x ? r.max_x - r.min_x : 0;\n}\n\nstatic inline uint32_t wuffs_base__rectangle__height(wuffs_base__rectangle r) {\n return r.max_y > r.min_y ? r.max_y - r.min_y : 0;\n}\n\n// wuffs_base__slice_u8 is a 1-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty slice.\ntypedef struct {\n uint8_t* ptr;\n size_t len;\n} wuffs_base__slice_u8;\n\n// wuffs_base__table_u8 is a 2-dimensional buffer.\n//\n// A value with all fields NULL or zero is a valid, empty table.\ntypedef struct {\n uint8_t* ptr;\n size_" +
"t width;\n size_t height;\n size_t stride;\n} wuffs_base__table_u8;\n\n// ---------------- I/O\n\n// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.\n\n// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__buf1;\n\n// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__limit1 {\n uint64_t* ptr_to_len; " +
" // Pointer to N.\n struct wuffs_base__limit1* next; // Linked list of limits.\n} wuffs_base__limit1;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__buf1* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__limit1 limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__reader1;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__buf1* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__limit1 limit;\n uint8_t* mark;\n } private_impl" +
";\n} wuffs_base__writer1;\n\n// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The " +
"bit fields of a wuffs_base__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats with N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index)." +
" The distance\n// between successive palette elements is always 4 bytes.\n//\n// The color field is encoded in 3 bits:\n// - 0 means A (Alpha).\n// - 1 means Y or YA (Gray, Alpha).\n// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha).\n// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha).\n// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha).\n// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black).\n// - all other values are reserved.\n//\n// In Wuffs, channels are given in memory order, regardless of endianness,\n// since the C type for the pixel data is an array of bytes, not an array of\n// uint32_t. For example, packed BGRA with 8 bits per channel means that the\n// bytes in memory are always Blue, Green, Red then Alpha. On big-endian\n// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB.\n//\n// When the color field (3 bits) encodes multiple options, the transparency\n// field (2 bits) distinguishes them:\n// - " +
"0 means fully opaque, no extra channels\n// - 1 means fully opaque, one extra channel (X or K, padding or black).\n// - 2 means one extra alpha channel, other channels are non-premultiplied.\n// - 3 means one extra alpha channel, other channels are premultiplied.\n//\n// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is\n// invalid to combine the zero color (alpha only) with the zero transparency.\n//\n// Bit depth is encoded in 4 bits:\n// - 0 means the channel or index is unused.\n// - x means a bit depth of x, for x in the range 1..8.\n// - 9 means a bit depth of 10.\n// - 10 means a bit depth of 12.\n// - 11 means a bit depth of 16.\n// - 12 means a bit depth of 24.\n// - 13 means a bit depth of 32.\n// - 14 means a bit depth of 48.\n// - 15 means a bit depth of 64.\n//\n// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for\n// decoding a PNG image - network byte order (also known as big-endian),\n// packed, non-premultiplied alpha - that happens to be 16-bi" +
"t-depth truecolor\n// with alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel format value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and t" +
"he Wayland-DRM library's WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIX" +
"EL_FORMAT__Y ((wuffs_base__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PI" +
"XEL_FORMAT__RGBA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_" +
"base__pixel_format f) {\n return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >>" +
" shift_y.\n// where biases and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-image may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE_" +
"_PIXEL_SUBSAMPLING__NONE ((wuffs_base__pixel_subsampling)0);\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x202000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100);\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t" +
" wuffs_base__pixel_subsampling__bias_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n uint32_t num_loops;\n } private_impl;\n} wuffs_base__image_config;\n\nstatic inline void wuffs_base__image_config__initialize(\n wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops) {\n if (!c) {\n return;\n }\n // TODO: move the check from wuffs" +
"_base__image_config__is_valid here. Should\n // this function return bool? An error type?\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_impl.num_loops = num_loops;\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n if (!c || !c->private_impl.pixfmt) {\n return false;\n }\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n //\n // TODO: move the check to wuffs_base__image_config__initialize.\n return wh <= ((uint64_t)SIZE_MAX);\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_" +
"subsampling\nwuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.num_loops : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (wuffs_" +
"base__image_config__is_valid(c)) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__image_config config;\n uint32_t loop_count; // 0-based count of the current loop.\n wuffs_base__pixel_buffer pixbuf;\n // TODO: color spaces.\n wuffs_base__rectangle dirty_rect;\n wuffs_base__flicks duration;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__initialize(\n wuffs_base__image_buffer* f,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!f) {\n return;\n }\n *f = ((wuffs_base__image_buffer){});\n f->private_impl.config = config;\n f->private_impl.pixbuf = pixbuf;\n}\n\nstatic inline void wu" +
"ffs_base__image_buffer__update(\n wuffs_base__image_buffer* f,\n wuffs_base__rectangle dirty_rect,\n wuffs_base__flicks duration,\n uint8_t* palette_ptr,\n size_t palette_len) {\n if (!f) {\n return;\n }\n f->private_impl.dirty_rect = dirty_rect;\n f->private_impl.duration = duration;\n if (palette_ptr) {\n memmove(f->private_impl.palette, palette_ptr,\n palette_len <= 1024 ? palette_len : 1024);\n }\n}\n\n// wuffs_base__image_buffer__loop returns whether the image decoder should loop\n// back to the beginning of the animation, assuming that we've reached the end\n// of the encoded stream. If so, it increments f's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {\n if (!f) {\n return false;\n }\n uint32_t n = f->private_impl.config.private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (f->private_impl.loop_count < n - 1) {\n f->private_impl.loop_count++;\n return true;\n }\n return false;\n}\n\n// w" +
"uffs_base__image_buffer__dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside f and has length 1024.\nstatic inline uint8_t* wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.palette : NULL;\n}\n\n#endif // WUFFS_BASE_HEADER_H\n" +
"t width;\n size_t height;\n size_t stride;\n} wuffs_base__table_u8;\n\n// ---------------- I/O\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__io_limit {\n uint64_t* ptr_to_len; // Pointer to N.\n struct wuffs_base__io_limi" +
"t* next; // Linked list of limits.\n} wuffs_base__io_limit;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n" +
"\n// ---------------- Images\n\n// wuffs_base__pixel_format encodes the format of the bytes that constitute an\n// image frame's pixel data. Its bits:\n// - bit 31 is reserved.\n// - bits 30 .. 28 encodes color (and channel order, in terms of memory).\n// - bits 27 .. 26 are reserved.\n// - bits 25 .. 24 encodes transparency.\n// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).\n// - bit 22 indicates floating point (as opposed to integer).\n// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.\n// - bits 19 .. 16 encodes the number of bits (depth) in an index value.\n// Zero means direct, not palette-indexed.\n// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.\n// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.\n// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.\n// - bits 3 .. 0 encodes the number of bits (depth) in the 0th channel.\n//\n// The bit fields of a wuffs_bas" +
"e__pixel_format are not independent. For\n// example, the number of planes should not be greater than the number of\n// channels. Similarly, bits 15..4 are unused (and should be zero) if bits\n// 31..24 (color and transparency) together imply only 1 channel (gray, no\n// alpha) and floating point samples should mean a bit depth of 16, 32 or 64.\n//\n// Formats hold between 1 and 4 channels. For example: Y (1 channel: gray), YA\n// (2 channels: gray and alpha), BGR (3 channels: blue, green, red) or CMYK (4\n// channels: cyan, magenta, yellow, black).\n//\n// For direct formats with N > 1 channels, those channels can be laid out in\n// either 1 (packed) or N (planar) planes. For example, RGBA data is usually\n// packed, but YUV data is usually planar, due to chroma subsampling (for\n// details, see the wuffs_base__pixel_subsampling type). For indexed formats,\n// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data\n// per index value, and there is only 1 plane (for the index). The distance\n// between " +
"successive palette elements is always 4 bytes.\n//\n// The color field is encoded in 3 bits:\n// - 0 means A (Alpha).\n// - 1 means Y or YA (Gray, Alpha).\n// - 2 means BGR, BGRX or BGRA (Blue, Green, Red, X-padding or Alpha).\n// - 3 means RGB, RGBX or RGBA (Red, Green, Blue, X-padding or Alpha).\n// - 4 means YUV or YUVA (Luma, Chroma-blue, Chroma-red, Alpha).\n// - 5 means CMY or CMYK (Cyan, Magenta, Yellow, Black).\n// - all other values are reserved.\n//\n// In Wuffs, channels are given in memory order, regardless of endianness,\n// since the C type for the pixel data is an array of bytes, not an array of\n// uint32_t. For example, packed BGRA with 8 bits per channel means that the\n// bytes in memory are always Blue, Green, Red then Alpha. On big-endian\n// systems, that is the uint32_t 0xBBGGRRAA. On little-endian, 0xAARRGGBB.\n//\n// When the color field (3 bits) encodes multiple options, the transparency\n// field (2 bits) distinguishes them:\n// - 0 means fully opaque, no " +
"extra channels\n// - 1 means fully opaque, one extra channel (X or K, padding or black).\n// - 2 means one extra alpha channel, other channels are non-premultiplied.\n// - 3 means one extra alpha channel, other channels are premultiplied.\n//\n// The zero wuffs_base__pixel_format value is an invalid pixel format, as it is\n// invalid to combine the zero color (alpha only) with the zero transparency.\n//\n// Bit depth is encoded in 4 bits:\n// - 0 means the channel or index is unused.\n// - x means a bit depth of x, for x in the range 1..8.\n// - 9 means a bit depth of 10.\n// - 10 means a bit depth of 12.\n// - 11 means a bit depth of 16.\n// - 12 means a bit depth of 24.\n// - 13 means a bit depth of 32.\n// - 14 means a bit depth of 48.\n// - 15 means a bit depth of 64.\n//\n// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for\n// decoding a PNG image - network byte order (also known as big-endian),\n// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor\n// with" +
" alpha (RGBA). In memory order:\n//\n// ptr+0 ptr+1 ptr+2 ptr+3 ptr+4 ptr+5 ptr+6 ptr+7\n// Rhi Rlo Ghi Glo Bhi Blo Ahi Alo\n//\n// For example, the value wuffs_base__pixel_format 0x20000565 means BGR with no\n// alpha or padding, 5/6/5 bits for blue/green/red, packed 2 bytes per pixel,\n// laid out LSB-first in memory order:\n//\n// ptr+0........... ptr+1...........\n// MSB LSB MSB LSB\n// G₂G₁G₀B₄B₃B₂B₁B₀ R₄R₃R₂R₁R₀G₅G₄G₃\n//\n// On little-endian systems (but not big-endian), this Wuffs pixel format value\n// (0x20000565) corresponds to the Cairo library's CAIRO_FORMAT_RGB16_565, the\n// SDL2 (Simple DirectMedia Layer 2) library's SDL_PIXELFORMAT_RGB565 and the\n// Skia library's kRGB_565_SkColorType. Note BGR in Wuffs versus RGB in the\n// other libraries.\n//\n// Regardless of endianness, this Wuffs pixel format value (0x20000565)\n// corresponds to the V4L2 (Video For Linux 2) library's V4L2_PIX_FMT_RGB565\n// and the Wayland-DRM library's " +
"WL_DRM_FORMAT_RGB565.\n//\n// Different software libraries name their pixel formats (and especially their\n// channel order) either according to memory layout or as bits of a native\n// integer type like uint32_t. The two conventions differ because of a system's\n// endianness. As mentioned earlier, Wuffs pixel formats are always in memory\n// order. More detail of other software libraries' naming conventions is in the\n// Pixel Format Guide at https://afrantzis.github.io/pixel-format-guide/\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_format__num_planes instead.\ntypedef uint32_t wuffs_base__pixel_format;\n\n// Common 8-bit-depth pixel formats. This list is not exhaustive; not all valid\n// wuffs_base__pixel_format values are present.\n\n#define WUFFS_BASE__PIXEL_FORMAT__INVALID ((wuffs_base__pixel_format)0x00000000)\n\n#define WUFFS_BASE__PIXEL_FORMAT__A ((wuffs_base__pixel_format)0x02000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__Y ((wuffs_base" +
"__pixel_format)0x10000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x12000008)\n#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \\\n ((wuffs_base__pixel_format)0x13000008)\n\n#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \\\n ((wuffs_base__pixel_format)0x21088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x22008888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x22088888)\n#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \\\n ((wuffs_base__pixel_format)0x23008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \\\n ((wuffs_base__pixel_format)0x31088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMU" +
"L \\\n ((wuffs_base__pixel_format)0x32008888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \\\n ((wuffs_base__pixel_format)0x32088888)\n#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \\\n ((wuffs_base__pixel_format)0x33008888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)\n#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \\\n ((wuffs_base__pixel_format)0x42308888)\n\n#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)\n#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)\n\nstatic inline bool wuffs_base__pixel_format__is_valid(\n wuffs_base__pixel_format f) {\n return f != 0;\n}\n\nstatic inline bool wuffs_base__pixel_format__is_indexed(\n wuffs_base__pixel_format f) {\n return ((f >> 16) & 0x0F) != 0;\n}\n\n#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4\n\nstatic inline uint32_t wuffs_base__pixel_format__num_planes(\n wuffs_base__pixel_format f) {\n " +
" return f ? (((f >> 20) & 0x03) + 1) : 0;\n}\n\ntypedef struct {\n wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];\n} wuffs_base__pixel_buffer;\n\n// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates\n// (x, y) to pixel buffer indices (i, j). That mapping can differ for each\n// plane p. For a depth of 8 bits (1 byte), the p'th plane's sample starts at\n// (planes[p].ptr + (j * planes[p].stride) + i).\n//\n// For packed pixel formats, the mapping is trivial: i = x and j = y. For\n// planar pixel formats, the mapping can differ due to chroma subsampling. For\n// example, consider a three plane YUV pixel format with 4:2:2 subsampling. For\n// the luma (Y) channel, there is one sample for every pixel, but for the\n// chroma (U, V) channels, there is one sample for every two pixels: pairs of\n// horizontally adjacent pixels form one macropixel, i = x / 2 and j == y. In\n// general, for a given p:\n// - i = (x + bias_x) >> shift_x.\n// - j = (y + bias_y) >> shift_y.\n// where biases" +
" and shifts are in the range 0..3 and 0..2 respectively.\n//\n// In general, the biases will be zero after decoding an image. However, making\n// a sub-image may change the bias, since the (x, y) coordinates are relative\n// to the sub-image's top-left origin, but the backing pixel buffers were\n// created relative to the original image's origin.\n//\n// For each plane p, each of those four numbers (biases and shifts) are encoded\n// in two bits, which combine to form an 8 bit unsigned integer:\n//\n// e_p = (bias_x << 6) | (shift_x << 4) | (bias_y << 2) | (shift_y << 0)\n//\n// Those e_p values (e_0 for the first plane, e_1 for the second plane, etc)\n// combine to form a wuffs_base__pixel_subsampling value:\n//\n// pixsub = (e_3 << 24) | (e_2 << 16) | (e_1 << 8) | (e_0 << 0)\n//\n// Do not manipulate these bits directly; they are private implementation\n// details. Use methods such as wuffs_base__pixel_subsampling__bias_x instead.\ntypedef uint32_t wuffs_base__pixel_subsampling;\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__NONE " +
"((wuffs_base__pixel_subsampling)0);\n\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__444 \\\n ((wuffs_base__pixel_subsampling)0x000000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__440 \\\n ((wuffs_base__pixel_subsampling)0x010100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__422 \\\n ((wuffs_base__pixel_subsampling)0x101000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__420 \\\n ((wuffs_base__pixel_subsampling)0x111100);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__411 \\\n ((wuffs_base__pixel_subsampling)0x202000);\n#define WUFFS_BASE__PIXEL_SUBSAMPLING__410 \\\n ((wuffs_base__pixel_subsampling)0x212100);\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__bias_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 6;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_x(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 4;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsam" +
"pling__bias_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 2;\n return (s >> shift) & 0x03;\n}\n\nstatic inline uint32_t wuffs_base__pixel_subsampling__shift_y(\n wuffs_base__pixel_subsampling s,\n uint32_t plane) {\n uint32_t shift = ((plane & 0x03) * 8) + 0;\n return (s >> shift) & 0x03;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__pixel_format pixfmt;\n wuffs_base__pixel_subsampling pixsub;\n uint32_t width;\n uint32_t height;\n uint32_t num_loops;\n } private_impl;\n} wuffs_base__image_config;\n\nstatic inline void wuffs_base__image_config__initialize(\n wuffs_base__image_config* c,\n wuffs_base__pixel_format pixfmt,\n wuffs_base__pixel_subsampling pixsub,\n uint32_t width,\n uint32_t height,\n uint32_t num_loops) {\n if (!c) {\n return;\n }\n // TODO: move the check from wuffs_base__image_config__is_v" +
"alid here. Should\n // this function return bool? An error type?\n c->private_impl.pixfmt = pixfmt;\n c->private_impl.pixsub = pixsub;\n c->private_impl.width = width;\n c->private_impl.height = height;\n c->private_impl.num_loops = num_loops;\n}\n\nstatic inline void wuffs_base__image_config__invalidate(\n wuffs_base__image_config* c) {\n if (c) {\n *c = ((wuffs_base__image_config){});\n }\n}\n\nstatic inline bool wuffs_base__image_config__is_valid(\n wuffs_base__image_config* c) {\n if (!c || !c->private_impl.pixfmt) {\n return false;\n }\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n //\n // TODO: move the check to wuffs_base__image_config__initialize.\n return wh <= ((uint64_t)SIZE_MAX);\n}\n\nstatic inline wuffs_base__pixel_format wuffs_base__image_config__pixel_format(\n wuffs_base__image_config* c) {\n return c ? c->private_impl.pixfmt : 0;\n}\n\nstatic inline wuffs_base__pixel_subsampling\nwuffs_base__i" +
"mage_config__pixel_subsampling(wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.pixsub : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__width(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.width : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__height(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.height : 0;\n}\n\nstatic inline uint32_t wuffs_base__image_config__num_loops(\n wuffs_base__image_config* c) {\n return wuffs_base__image_config__is_valid(c) ? c->private_impl.num_loops : 0;\n}\n\n// TODO: this is the right API for planar (not packed) pixbufs? Should it allow\n// decoding into a color model different from the format's intrinsic one? For\n// example, decoding a JPEG image straight to RGBA instead of to YCbCr?\nstatic inline size_t wuffs_base__image_config__pixbuf_size(\n wuffs_base__image_config* c) {\n if (wuffs_base__image_config__is_va" +
"lid(c)) {\n uint64_t wh =\n ((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);\n // TODO: handle things other than 1 byte per pixel.\n return (size_t)wh;\n }\n return 0;\n}\n\ntypedef struct {\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__image_config config;\n uint32_t loop_count; // 0-based count of the current loop.\n wuffs_base__pixel_buffer pixbuf;\n // TODO: color spaces.\n wuffs_base__rectangle dirty_rect;\n wuffs_base__flicks duration;\n uint8_t palette[1024];\n } private_impl;\n} wuffs_base__image_buffer;\n\nstatic inline void wuffs_base__image_buffer__initialize(\n wuffs_base__image_buffer* f,\n wuffs_base__image_config config,\n wuffs_base__pixel_buffer pixbuf) {\n if (!f) {\n return;\n }\n *f = ((wuffs_base__image_buffer){});\n f->private_impl.config = config;\n f->private_impl.pixbuf = pixbuf;\n}\n\nstatic inline void wuffs_base__image_buffer__u" +
"pdate(\n wuffs_base__image_buffer* f,\n wuffs_base__rectangle dirty_rect,\n wuffs_base__flicks duration,\n uint8_t* palette_ptr,\n size_t palette_len) {\n if (!f) {\n return;\n }\n f->private_impl.dirty_rect = dirty_rect;\n f->private_impl.duration = duration;\n if (palette_ptr) {\n memmove(f->private_impl.palette, palette_ptr,\n palette_len <= 1024 ? palette_len : 1024);\n }\n}\n\n// wuffs_base__image_buffer__loop returns whether the image decoder should loop\n// back to the beginning of the animation, assuming that we've reached the end\n// of the encoded stream. If so, it increments f's count of the animation loops\n// played so far.\nstatic inline bool wuffs_base__image_buffer__loop(wuffs_base__image_buffer* f) {\n if (!f) {\n return false;\n }\n uint32_t n = f->private_impl.config.private_impl.num_loops;\n if (n == 0) {\n return true;\n }\n if (f->private_impl.loop_count < n - 1) {\n f->private_impl.loop_count++;\n return true;\n }\n return false;\n}\n\n// wuffs_base__image_buffer__" +
"dirty_rect returns an upper bound for what part of\n// this frame's pixels differs from the previous frame.\nstatic inline wuffs_base__rectangle wuffs_base__image_buffer__dirty_rect(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.dirty_rect : ((wuffs_base__rectangle){0});\n}\n\n// wuffs_base__image_buffer__duration returns the amount of time to display\n// this frame. Zero means to display forever - a still (non-animated) image.\nstatic inline wuffs_base__flicks wuffs_base__image_buffer__duration(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.duration : 0;\n}\n\n// wuffs_base__image_buffer__palette returns the palette that the pixel data\n// can index. The backing array is inside f and has length 1024.\nstatic inline uint8_t* wuffs_base__image_buffer__palette(\n wuffs_base__image_buffer* f) {\n return f ? f->private_impl.palette : NULL;\n}\n\n#endif // WUFFS_BASE_HEADER_H\n" +
""
const baseImpl = "" +
@@ -48,12 +48,12 @@ const baseImpl = "" +
"(expr) (__builtin_expect(!!(expr), 1))\n#define WUFFS_BASE__UNLIKELY(expr) (__builtin_expect(!!(expr), 0))\n#else\n#define WUFFS_BASE__LIKELY(expr) (expr)\n#define WUFFS_BASE__UNLIKELY(expr) (expr)\n#endif\n\n// Uncomment this #include for printf-debugging.\n// #include <stdio.h>\n\n// ---------------- Static Inline Functions\n//\n// The helpers below are functions, instead of macros, because their arguments\n// can be an expression that we shouldn't evaluate more than once.\n//\n// They are in base-impl.h and hence copy/pasted into every generated C file,\n// instead of being in some \"base.c\" file, since a design goal is that users of\n// the generated C code can often just #include a single .c file, such as\n// \"gif.c\", without having to additionally include or otherwise build and link\n// a \"base.c\" file.\n//\n// They are static, so that linking multiple wuffs .o files won't complain about\n// duplicate function definitions.\n//\n// They are explicitly marked inline, even if modern compilers don't use the\n// inline attribute to g" +
"uide optimizations such as inlining, to avoid the\n// -Wunused-function warning, and we like to compile with -Wall -Werror.\n\nstatic inline uint16_t wuffs_base__load_u16be(uint8_t* p) {\n return ((uint16_t)(p[0]) << 8) | ((uint16_t)(p[1]) << 0);\n}\n\nstatic inline uint16_t wuffs_base__load_u16le(uint8_t* p) {\n return ((uint16_t)(p[0]) << 0) | ((uint16_t)(p[1]) << 8);\n}\n\nstatic inline uint32_t wuffs_base__load_u32be(uint8_t* p) {\n return ((uint32_t)(p[0]) << 24) | ((uint32_t)(p[1]) << 16) |\n ((uint32_t)(p[2]) << 8) | ((uint32_t)(p[3]) << 0);\n}\n\nstatic inline uint32_t wuffs_base__load_u32le(uint8_t* p) {\n return ((uint32_t)(p[0]) << 0) | ((uint32_t)(p[1]) << 8) |\n ((uint32_t)(p[2]) << 16) | ((uint32_t)(p[3]) << 24);\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_i(\n wuffs_base__slice_u8 s,\n uint64_t i) {\n if ((i <= SIZE_MAX) && (i <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = s.len - i,\n });\n }\n return ((wuffs_base__sli" +
"ce_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_j(\n wuffs_base__slice_u8 s,\n uint64_t j) {\n if ((j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){.ptr = s.ptr, .len = j});\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__subslice_ij(\n wuffs_base__slice_u8 s,\n uint64_t i,\n uint64_t j) {\n if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {\n return ((wuffs_base__slice_u8){\n .ptr = s.ptr + i,\n .len = j - i,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\n// wuffs_base__slice_u8__prefix returns up to the first up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8__prefix(\n wuffs_base__slice_u8 s,\n uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__suffix returns up to the last up_to bytes of s.\nstatic inline wuffs_base__slice_u8 wuffs_base__slice_u8_suffix(\n wuffs_base__slice_u8 s,\n " +
" uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked writer1.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n s" +
"tart = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__writer1__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__writer1__copy_from_history32__bco is a Bounds Check Optimized\n// version of the " +
"wuffs_base__writer1__copy_from_history32 function above. The\n// caller needs to prove that:\n// - start != NULL\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__writer1__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n > 0) {\n memm" +
"ove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__writer1__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\nstatic inline uint32_t wuffs_base__writer1__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the reader1 and writer1's private_impl fields (including\n// " +
"limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs code, not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__reader1 wuffs_base__reader1__limit(\n wuffs_base__reader1* o,\n uint64_t* ptr_to_len) {\n wuffs_base__reader1 ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__reader1__mark(\n wuffs_base__reader1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__writer1 wuffs_base__writer1__limit()\n\nstatic" +
" inline wuffs_base__empty_struct wuffs_base__writer1__mark(\n wuffs_base__writer1* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" +
" uint64_t up_to) {\n if ((uint64_t)(s.len) > up_to) {\n s.ptr += (uint64_t)(s.len) - up_to;\n s.len = up_to;\n }\n return s;\n}\n\n// wuffs_base__slice_u8__copy_from_slice calls memmove(dst.ptr, src.ptr,\n// length) where length is the minimum of dst.len and src.len.\n//\n// Passing a wuffs_base__slice_u8 with all fields NULL or zero (a valid, empty\n// slice) is valid and results in a no-op.\nstatic inline uint64_t wuffs_base__slice_u8__copy_from_slice(\n wuffs_base__slice_u8 dst,\n wuffs_base__slice_u8 src) {\n size_t length = dst.len < src.len ? dst.len : src.len;\n if (length > 0) {\n memmove(dst.ptr, src.ptr, length);\n }\n return length;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_history32(\n uint8_t** ptr_ptr,\n uint8_t* start, // May be NULL, meaning an unmarked io_writer.\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n if (!start || !distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }" +
"\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_from_history32 Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__io_writer__copy_from_history32__bco below.\n //\n // Alternatively, or additionally, have a sloppy_copy_from_history32 method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__io_writer__copy_from_history32__bco is a Bounds Check Optimized\n// version" +
" of the wuffs_base__io_writer__copy_from_history32 function above.\n// The caller needs to prove that:\n// - start != NULL\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(\n uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t distance,\n uint32_t length) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_reader32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n uint8_t** ptr_rptr,\n uint8_t* rend,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = length;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n uint8_t* rptr = *ptr_rptr;\n if (n > rend - rptr) {\n n = rend - rptr;\n }\n if (n >" +
" 0) {\n memmove(wptr, rptr, n);\n *ptr_wptr += n;\n *ptr_rptr += n;\n }\n return n;\n}\n\nstatic inline uint64_t wuffs_base__io_writer__copy_from_slice(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\nstatic inline uint32_t wuffs_base__io_writer__copy_from_slice32(\n uint8_t** ptr_wptr,\n uint8_t* wend,\n wuffs_base__slice_u8 src,\n uint32_t length) {\n uint8_t* wptr = *ptr_wptr;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > wend - wptr) {\n n = wend - wptr;\n }\n if (n > 0) {\n memmove(wptr, src.ptr, n);\n *ptr_wptr += n;\n }\n return n;\n}\n\n// Note that the *__limit and *__mark methods are private (in base-impl.h) not\n// public (in base-header.h). We assume that, at the boundary between user code\n// and Wuffs code, the io_reader and io_writer's private_impl" +
" fields (including\n// limit and mark) are NULL. Otherwise, some internal assumptions break down.\n// For example, limits could be represented as pointers, even though\n// conceptually they are counts, but that pointer-to-count correspondence\n// becomes invalid if a buffer is re-used (e.g. on resuming a coroutine).\n//\n// Admittedly, some of the Wuffs test code calls these methods, but that test\n// code is still Wuffs code, not user code. Other Wuffs test code modifies\n// private_impl fields directly.\n\nstatic inline wuffs_base__io_reader wuffs_base__io_reader__limit(\n wuffs_base__io_reader* o,\n uint64_t* ptr_to_len) {\n wuffs_base__io_reader ret = *o;\n ret.private_impl.limit.ptr_to_len = ptr_to_len;\n ret.private_impl.limit.next = &o->private_impl.limit;\n return ret;\n}\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_reader__mark(\n wuffs_base__io_reader* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\n// TODO: static inline wuffs_base__io_writer " +
"wuffs_base__io_writer__limit()\n\nstatic inline wuffs_base__empty_struct wuffs_base__io_writer__mark(\n wuffs_base__io_writer* o,\n uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" +
""
type template_args_short_read struct {
+25 -25
View File
@@ -175,7 +175,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
return fmt.Errorf(`TODO: cgen an "in.src.limit" expression`)
}
if isInSrc(g.tm, n, t.KeyMark, 0) {
b.printf("wuffs_base__reader1__mark(&%ssrc, %srptr_src)", aPrefix, bPrefix)
b.printf("wuffs_base__io_reader__mark(&%ssrc, %srptr_src)", aPrefix, bPrefix)
return nil
}
if isInSrc(g.tm, n, t.KeySinceMark, 0) {
@@ -185,16 +185,16 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
aPrefix, aPrefix, bPrefix, aPrefix)
return nil
}
// TODO: reader1.is_marked, not just writer1.is_marked?
// TODO: io_reader.is_marked, not just io_writer.is_marked?
if isInDst(g.tm, n, t.KeyLimit, 1) {
return fmt.Errorf(`TODO: cgen an "in.dst.limit" expression`)
}
if isInDst(g.tm, n, t.KeyMark, 0) {
// TODO: is a private_impl.mark the right representation? What if
// the function is passed a (ptr writer1) instead of a (writer1)?
// Do we still want to have that mark live outside of the function
// scope?
b.printf("wuffs_base__writer1__mark(&%sdst, %swptr_dst)", aPrefix, bPrefix)
// the function is passed a (ptr io_writer) instead of a
// (io_writer)? Do we still want to have that mark live outside of
// the function scope?
b.printf("wuffs_base__io_writer__mark(&%sdst, %swptr_dst)", aPrefix, bPrefix)
return nil
}
if isInDst(g.tm, n, t.KeySinceMark, 0) {
@@ -224,7 +224,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
return nil
}
if isInDst(g.tm, n, t.KeyCopyFromReader32, 2) {
b.printf("wuffs_base__writer1__copy_from_reader32(&%swptr_dst, %swend_dst", bPrefix, bPrefix)
b.printf("wuffs_base__io_writer__copy_from_reader32(&%swptr_dst, %swend_dst",
bPrefix, bPrefix)
// TODO: don't assume that the first argument is "in.src".
b.printf(", &%srptr_src, %srend_src,", bPrefix, bPrefix)
a := n.Args()[1].Arg().Value()
@@ -239,7 +240,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
if n.BoundsCheckOptimized() {
bco = "__bco"
}
b.printf("wuffs_base__writer1__copy_from_history32%s(&%swptr_dst, %sdst.private_impl.mark , %swend_dst",
b.printf("wuffs_base__io_writer__copy_from_history32%s("+
"&%swptr_dst, %sdst.private_impl.mark , %swend_dst",
bco, bPrefix, aPrefix, bPrefix)
for _, o := range n.Args() {
b.writeb(',')
@@ -251,7 +253,8 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
return nil
}
if isInDst(g.tm, n, t.KeyCopyFromSlice32, 2) {
b.printf("wuffs_base__writer1__copy_from_slice32(&%swptr_dst, %swend_dst", bPrefix, bPrefix)
b.printf("wuffs_base__io_writer__copy_from_slice32("+
"&%swptr_dst, %swend_dst", bPrefix, bPrefix)
for _, o := range n.Args() {
b.writeb(',')
if err := g.writeExpr(b, o.Arg().Value(), rp, parenthesesOptional, depth); err != nil {
@@ -262,7 +265,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
return nil
}
if isInDst(g.tm, n, t.KeyCopyFromSlice, 1) {
b.printf("wuffs_base__writer1__copy_from_slice(&%swptr_dst, %swend_dst,", bPrefix, bPrefix)
b.printf("wuffs_base__io_writer__copy_from_slice(&%swptr_dst, %swend_dst,", bPrefix, bPrefix)
a := n.Args()[0].Arg().Value()
if err := g.writeExpr(b, a, rp, parenthesesOptional, depth); err != nil {
return err
@@ -352,7 +355,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare
}
if isThatMethod(g.tm, n, t.KeyMark, 0) {
// TODO: don't hard-code v_r or b_rptr_src.
b.printf("wuffs_base__reader1__mark(&v_r, b_rptr_src)")
b.printf("wuffs_base__io_reader__mark(&v_r, b_rptr_src)")
return nil
}
if isThatMethod(g.tm, n, t.KeySinceMark, 0) {
@@ -624,20 +627,17 @@ func (g *gen) writeCTypeName(b *buffer, n *a.TypeExpr, varNamePrefix string, var
}
var cTypeNames = [...]string{
t.KeyI8: "int8_t",
t.KeyI16: "int16_t",
t.KeyI32: "int32_t",
t.KeyI64: "int64_t",
t.KeyU8: "uint8_t",
t.KeyU16: "uint16_t",
t.KeyU32: "uint32_t",
t.KeyU64: "uint64_t",
t.KeyUsize: "size_t",
t.KeyBool: "bool",
t.KeyBuf1: "wuffs_base__buf1",
t.KeyReader1: "wuffs_base__reader1",
t.KeyWriter1: "wuffs_base__writer1",
t.KeyBuf2: "wuffs_base__buf2",
t.KeyI8: "int8_t",
t.KeyI16: "int16_t",
t.KeyI32: "int32_t",
t.KeyI64: "int64_t",
t.KeyU8: "uint8_t",
t.KeyU16: "uint16_t",
t.KeyU32: "uint32_t",
t.KeyU64: "uint64_t",
t.KeyBool: "bool",
t.KeyIOReader: "wuffs_base__io_reader",
t.KeyIOWriter: "wuffs_base__io_writer",
}
var cOpNames = [256]string{
+9 -10
View File
@@ -401,14 +401,13 @@ func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error {
}
var numTypeBounds = [256][2]*big.Int{
t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
t.KeyUsize: {zero, zero},
t.KeyBool: {zero, one},
t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
t.KeyBool: {zero, one},
}
+2 -2
View File
@@ -442,7 +442,7 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
// TODO: delete these hacks that only matches "in.src.read_u8?()" etc.
//
// TODO: check reader1.buf and writer1.buf is non-NULL.
// TODO: check io_reader.buf and io_writer.buf is non-NULL.
if isInSrc(g.tm, n, t.KeyReadU8, 0) {
if g.currFunk.tempW > maxTemp {
return fmt.Errorf("too many temporary variables required")
@@ -682,7 +682,7 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
// TODO: don't hard-code a_dst or v_r or l_rlimit or v_block_size.
b.writes("uint64_t l_rlimit0 = v_block_size;\n")
b.printf("%sstatus %s%d = %slzw_decoder__decode(&self->private_impl.f_lzw, %sdst,"+
"wuffs_base__reader1__limit(&%sr, &l_rlimit0));\n",
"wuffs_base__io_reader__limit(&%sr, &l_rlimit0));\n",
g.pkgPrefix, tPrefix, temp,
g.pkgPrefix, aPrefix, vPrefix)
if err := g.writeLoadExprDerivedVars(b, n); err != nil {
+9 -9
View File
@@ -66,7 +66,7 @@ func (g *gen) findDerivedVars() {
switch oTyp.QID() {
default:
continue
case t.QID{0, t.IDReader1}, t.QID{0, t.IDWriter1}:
case t.QID{0, t.IDIOReader}, t.QID{0, t.IDIOWriter}:
// No-op.
}
if !g.needDerivedVar(o.Name()) {
@@ -94,7 +94,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header
}
nameStr := name.Str(g.tm)
switch typ.QID() {
case t.QID{0, t.IDReader1}:
case t.QID{0, t.IDIOReader}:
if header {
b.printf("uint8_t* %srptr_%s = NULL;", bPrefix, nameStr)
b.printf("uint8_t* %srstart_%s = NULL;", bPrefix, nameStr)
@@ -110,7 +110,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header
b.printf("uint64_t len = %s%s.buf->wi - %s%s.buf->ri;", aPrefix, nameStr, aPrefix, nameStr)
b.printf("wuffs_base__limit1* lim;\n")
b.printf("wuffs_base__io_limit* lim;\n")
b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {\n")
b.printf("len = *lim->ptr_to_len;\n")
@@ -122,7 +122,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header
b.printf("}\n")
case t.QID{0, t.IDWriter1}:
case t.QID{0, t.IDIOWriter}:
if header {
b.printf("uint8_t* %swptr_%s = NULL;", bPrefix, nameStr)
b.printf("uint8_t* %swstart_%s = NULL;", bPrefix, nameStr)
@@ -140,7 +140,7 @@ func (g *gen) writeLoadDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, header
b.printf("if (!%s%s.buf->closed) {", aPrefix, nameStr)
b.printf("uint64_t len = %s%s.buf->len - %s%s.buf->wi;", aPrefix, nameStr, aPrefix, nameStr)
b.printf("wuffs_base__limit1* lim;\n")
b.printf("wuffs_base__io_limit* lim;\n")
b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {\n")
b.printf("len = *lim->ptr_to_len;\n")
@@ -171,14 +171,14 @@ func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer
}
nameStr := name.Str(g.tm)
switch typ.QID() {
case t.QID{0, t.IDReader1}:
case t.QID{0, t.IDIOReader}:
b.printf("if (%s%s.buf) {", aPrefix, nameStr)
b.printf("size_t n = %srptr_%s - (%s%s.buf->ptr + %s%s.buf->ri);",
bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr)
b.printf("%s%s.buf->ri += n;", aPrefix, nameStr)
b.printf("wuffs_base__limit1* lim;\n")
b.printf("wuffs_base__io_limit* lim;\n")
b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len) {\n")
b.printf("*lim->ptr_to_len -= n;\n")
@@ -192,14 +192,14 @@ func (g *gen) writeSaveDerivedVar(b *buffer, name t.ID, typ *a.TypeExpr, footer
b.printf("}\n")
case t.QID{0, t.IDWriter1}:
case t.QID{0, t.IDIOWriter}:
b.printf("if (%s%s.buf) {", aPrefix, nameStr)
b.printf("size_t n = %swptr_%s - (%s%s.buf->ptr + %s%s.buf->wi);",
bPrefix, nameStr, aPrefix, nameStr, aPrefix, nameStr)
b.printf("%s%s.buf->wi += n;", aPrefix, nameStr)
b.printf("wuffs_base__limit1* lim;\n")
b.printf("wuffs_base__io_limit* lim;\n")
b.printf("for (lim = &%s%s.private_impl.limit; lim; lim = lim->next) {\n", aPrefix, nameStr)
b.printf("if (lim->ptr_to_len) {\n")
b.printf("*lim->ptr_to_len -= n;\n")
+1
View File
@@ -12,6 +12,7 @@
- Spun `std/zlib` out of `std/flate`.
- Let the `std/zlib` decoder ignore checksums.
- Renamed `std/flate` to `std/deflate`.
- Renamed `buf1`, `reader1`, etc to `io_buffer`, `io_reader`, etc.
- Supported animated (not just single frame) GIFs.
- Marked the `std/gif` LZW decoder as private.
- Marked some internal status codes as private.
+5 -5
View File
@@ -70,9 +70,9 @@ const char* play() {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__buf1 src = {
wuffs_base__io_buffer src = {
.ptr = src_buffer, .len = src_len, .wi = src_len, .closed = true};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_base__image_config ic = {{0}};
wuffs_gif__status s =
@@ -80,7 +80,7 @@ const char* play() {
if (s) {
return wuffs_gif__status__string(s);
}
if (!wuffs_base__image_config__valid(&ic)) {
if (!wuffs_base__image_config__is_valid(&ic)) {
return "invalid image configuration";
}
uint32_t width = wuffs_base__image_config__width(&ic);
@@ -111,8 +111,8 @@ const char* play() {
}
while (true) {
wuffs_base__buf1 dst = {.ptr = dst_buffer, .len = dst_len};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = dst_len};
wuffs_base__io_writer dst_writer = {.buf = &dst};
// TODO: provide API and support for when the frame rect is different from
// the image rect.
s = wuffs_gif__decoder__decode_frame(&dec, dst_writer, src_reader);
+4 -4
View File
@@ -48,11 +48,11 @@ static void ignore_return_value(int ignored) {}
static const char* decode() {
uint8_t dst_buffer[DST_BUFFER_SIZE];
wuffs_base__buf1 dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE};
wuffs_base__buf1 src = {
wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE};
wuffs_base__io_buffer src = {
.ptr = lgtm_ptr, .len = lgtm_len, .wi = lgtm_len, .closed = true};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_writer dst_writer = {.buf = &dst};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_deflate__decoder dec;
wuffs_deflate__decoder__initialize(&dec, WUFFS_VERSION, 0);
+7 -7
View File
@@ -65,15 +65,15 @@ static const char* decode() {
continue;
}
wuffs_base__buf1 src = {.ptr = src_buffer,
.len = SRC_BUFFER_SIZE,
.wi = n_src,
.closed = n_src == 0};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_buffer src = {.ptr = src_buffer,
.len = SRC_BUFFER_SIZE,
.wi = n_src,
.closed = n_src == 0};
wuffs_base__io_reader src_reader = {.buf = &src};
while (true) {
wuffs_base__buf1 dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE};
wuffs_base__io_writer dst_writer = {.buf = &dst};
wuffs_gzip__status s =
wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader);
+7 -7
View File
@@ -26,7 +26,7 @@ void intentional_segfault() {
*intentional_segfault_ptr = 0;
}
void fuzz(wuffs_base__reader1 src_reader, uint32_t hash);
void fuzz(wuffs_base__io_reader src_reader, uint32_t hash);
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
// Hash input as per https://en.wikipedia.org/wiki/Jenkins_hash_function
@@ -41,12 +41,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
hash ^= hash >> 11;
hash += hash << 15;
wuffs_base__buf1 src = {.ptr = (uint8_t*)(data),
.len = size,
.wi = size,
.ri = 0,
.closed = true};
fuzz((wuffs_base__reader1){.buf = &src}, hash);
wuffs_base__io_buffer src = {.ptr = (uint8_t*)(data),
.len = size,
.wi = size,
.ri = 0,
.closed = true};
fuzz((wuffs_base__io_reader){.buf = &src}, hash);
return 0;
}
+3 -3
View File
@@ -38,7 +38,7 @@ It should print "PASS", amongst other information, and exit(0).
#include "../../../gen/c/std/gif.c"
#include "../fuzzlib/fuzzlib.cc"
void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) {
void fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
void* pixbuf = NULL;
// Use a {} code block so that "goto exit" doesn't trigger "jump bypasses
@@ -64,8 +64,8 @@ void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) {
goto exit;
}
wuffs_base__buf1 dst = {.ptr = (uint8_t*)(pixbuf), .len = pixbuf_size};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__io_buffer dst = {.ptr = (uint8_t*)(pixbuf), .len = pixbuf_size};
wuffs_base__io_writer dst_writer = {.buf = &dst};
while (true) {
// TODO: handle the frame rect being larger than the image rect. The
+3 -3
View File
@@ -39,7 +39,7 @@ It should print "PASS", amongst other information, and exit(0).
#include "../../../gen/c/std/zlib.c"
#include "../fuzzlib/fuzzlib.cc"
void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) {
void fuzz(wuffs_base__io_reader src_reader, uint32_t hash) {
wuffs_zlib__status s;
wuffs_zlib__decoder dec;
wuffs_zlib__decoder__initialize(&dec, WUFFS_VERSION, 0);
@@ -51,8 +51,8 @@ void fuzz(wuffs_base__reader1 src_reader, uint32_t hash) {
const size_t dstbuf_size = 65536;
uint8_t dstbuf[dstbuf_size];
wuffs_base__buf1 dst = {.ptr = dstbuf, .len = dstbuf_size};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__io_buffer dst = {.ptr = dstbuf, .len = dstbuf_size};
wuffs_base__io_writer dst_writer = {.buf = &dst};
while (true) {
dst.wi = 0;
+32 -34
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -848,9 +846,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
static inline uint32_t wuffs_base__io_writer__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
uint8_t* start, // May be NULL, meaning an unmarked io_writer.
uint8_t* end,
uint32_t distance,
uint32_t length) {
@@ -874,7 +872,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
// 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.
// 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?
@@ -890,14 +888,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
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:
// 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__writer1__copy_from_history32__bco(
static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
@@ -918,7 +916,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_reader32(
static inline uint32_t wuffs_base__io_writer__copy_from_reader32(
uint8_t** ptr_wptr,
uint8_t* wend,
uint8_t** ptr_rptr,
@@ -941,7 +939,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32(
return n;
}
static inline uint64_t wuffs_base__writer1__copy_from_slice(
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src) {
@@ -957,7 +955,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__writer1__copy_from_slice32(
static inline uint32_t wuffs_base__io_writer__copy_from_slice32(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src,
@@ -979,7 +977,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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
// 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
@@ -989,26 +987,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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,
static inline wuffs_base__io_reader wuffs_base__io_reader__limit(
wuffs_base__io_reader* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 ret = *o;
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__reader1__mark(
wuffs_base__reader1* o,
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__writer1 wuffs_base__writer1__limit()
// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* o,
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){});
+85 -87
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -740,8 +738,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -940,9 +938,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
static inline uint32_t wuffs_base__io_writer__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
uint8_t* start, // May be NULL, meaning an unmarked io_writer.
uint8_t* end,
uint32_t distance,
uint32_t length) {
@@ -966,7 +964,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
// 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.
// 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?
@@ -982,14 +980,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
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:
// 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__writer1__copy_from_history32__bco(
static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
@@ -1010,7 +1008,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_reader32(
static inline uint32_t wuffs_base__io_writer__copy_from_reader32(
uint8_t** ptr_wptr,
uint8_t* wend,
uint8_t** ptr_rptr,
@@ -1033,7 +1031,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32(
return n;
}
static inline uint64_t wuffs_base__writer1__copy_from_slice(
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src) {
@@ -1049,7 +1047,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__writer1__copy_from_slice32(
static inline uint32_t wuffs_base__io_writer__copy_from_slice32(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src,
@@ -1071,7 +1069,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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
// 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
@@ -1081,26 +1079,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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,
static inline wuffs_base__io_reader wuffs_base__io_reader__limit(
wuffs_base__io_reader* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 ret = *o;
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__reader1__mark(
wuffs_base__reader1* o,
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__writer1 wuffs_base__writer1__limit()
// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* o,
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){});
@@ -1216,20 +1214,20 @@ static const uint32_t wuffs_deflate__dcode_magic_numbers[32] = {
static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
static wuffs_deflate__status wuffs_deflate__decoder__init_fixed_huffman(
wuffs_deflate__decoder* self);
static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman(
wuffs_deflate__decoder* self,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
static wuffs_deflate__status wuffs_deflate__decoder__init_huff(
wuffs_deflate__decoder* self,
@@ -1240,13 +1238,13 @@ static wuffs_deflate__status wuffs_deflate__decoder__init_huff(
static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
// ---------------- Initializer Implementations
@@ -1270,8 +1268,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_DEFLATE__ERROR_BAD_RECEIVER;
}
@@ -1297,7 +1295,7 @@ wuffs_deflate__status wuffs_deflate__decoder__decode(
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1319,13 +1317,13 @@ wuffs_deflate__status wuffs_deflate__decoder__decode(
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
while (true) {
wuffs_base__writer1__mark(&a_dst, b_wptr_dst);
wuffs_base__io_writer__mark(&a_dst, b_wptr_dst);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1408,7 +1406,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1424,8 +1422,8 @@ exit:
static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK;
uint32_t v_final;
@@ -1438,7 +1436,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1481,7 +1479,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1508,7 +1506,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1531,7 +1529,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1552,7 +1550,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_blocks(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1591,7 +1589,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1614,8 +1612,8 @@ short_read_src:
static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK;
uint32_t v_length;
@@ -1630,7 +1628,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed(
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1646,7 +1644,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1709,7 +1707,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_uncompressed(
}
v_length = ((v_length) & ((1 << (16)) - 1));
while (true) {
v_n_copied = wuffs_base__writer1__copy_from_reader32(
v_n_copied = wuffs_base__io_writer__copy_from_reader32(
&b_wptr_dst, b_wend_dst, &b_rptr_src, b_rend_src, v_length);
if (v_length <= v_n_copied) {
v_length = 0;
@@ -1743,7 +1741,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1755,7 +1753,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1841,7 +1839,7 @@ exit:
static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman(
wuffs_deflate__decoder* self,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK;
uint32_t v_bits;
@@ -1864,7 +1862,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__init_dynamic_huffman(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2085,7 +2083,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2389,8 +2387,8 @@ exit:
static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK;
uint32_t v_bits;
@@ -2416,7 +2414,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast(
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2432,7 +2430,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2679,7 +2677,7 @@ label_0_continue:;
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
while (true) {
v_n_copied = wuffs_base__writer1__copy_from_slice32(
v_n_copied = wuffs_base__io_writer__copy_from_slice32(
&b_wptr_dst, b_wend_dst,
wuffs_base__slice_u8__subslice_i(
((wuffs_base__slice_u8){.ptr = self->private_impl.f_history,
@@ -2690,7 +2688,7 @@ label_0_continue:;
goto label_1_break;
}
v_hlen -= v_n_copied;
wuffs_base__writer1__copy_from_slice32(
wuffs_base__io_writer__copy_from_slice32(
&b_wptr_dst, b_wend_dst,
((wuffs_base__slice_u8){.ptr = self->private_impl.f_history,
.len = 32768}),
@@ -2714,7 +2712,7 @@ label_0_continue:;
goto exit;
}
}
wuffs_base__writer1__copy_from_history32__bco(
wuffs_base__io_writer__copy_from_history32__bco(
&b_wptr_dst, a_dst.private_impl.mark, b_wend_dst, v_dist_minus_1 + 1,
v_length);
goto label_2_break;
@@ -2742,7 +2740,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2754,7 +2752,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2769,8 +2767,8 @@ exit:
static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_deflate__status status = WUFFS_DEFLATE__STATUS_OK;
uint32_t v_bits;
@@ -2796,7 +2794,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2812,7 +2810,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -3081,7 +3079,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
}
v_hdist = (self->private_impl.f_history_index - v_hdist);
while (true) {
v_n_copied = wuffs_base__writer1__copy_from_slice32(
v_n_copied = wuffs_base__io_writer__copy_from_slice32(
&b_wptr_dst, b_wend_dst,
wuffs_base__slice_u8__subslice_i(
((wuffs_base__slice_u8){.ptr = self->private_impl.f_history,
@@ -3105,7 +3103,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
label_5_break:;
if (v_hlen > 0) {
while (true) {
v_n_copied = wuffs_base__writer1__copy_from_slice32(
v_n_copied = wuffs_base__io_writer__copy_from_slice32(
&b_wptr_dst, b_wend_dst,
wuffs_base__slice_u8__subslice_i(
((wuffs_base__slice_u8){
@@ -3127,7 +3125,7 @@ static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_slow(
goto label_0_continue;
}
}
v_n_copied = wuffs_base__writer1__copy_from_history32(
v_n_copied = wuffs_base__io_writer__copy_from_history32(
&b_wptr_dst, a_dst.private_impl.mark, b_wend_dst,
v_dist_minus_1 + 1, v_length);
if (v_length <= v_n_copied) {
@@ -3178,7 +3176,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -3190,7 +3188,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
+92 -93
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -755,11 +753,11 @@ void wuffs_gif__decoder__initialize(wuffs_gif__decoder* self,
wuffs_gif__status wuffs_gif__decoder__decode_config(
wuffs_gif__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -958,9 +956,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
static inline uint32_t wuffs_base__io_writer__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
uint8_t* start, // May be NULL, meaning an unmarked io_writer.
uint8_t* end,
uint32_t distance,
uint32_t length) {
@@ -984,7 +982,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
// 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.
// 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?
@@ -1000,14 +998,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
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:
// 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__writer1__copy_from_history32__bco(
static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
@@ -1028,7 +1026,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_reader32(
static inline uint32_t wuffs_base__io_writer__copy_from_reader32(
uint8_t** ptr_wptr,
uint8_t* wend,
uint8_t** ptr_rptr,
@@ -1051,7 +1049,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32(
return n;
}
static inline uint64_t wuffs_base__writer1__copy_from_slice(
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src) {
@@ -1067,7 +1065,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__writer1__copy_from_slice32(
static inline uint32_t wuffs_base__io_writer__copy_from_slice32(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src,
@@ -1089,7 +1087,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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
// 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
@@ -1099,26 +1097,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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,
static inline wuffs_base__io_reader wuffs_base__io_reader__limit(
wuffs_base__io_reader* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 ret = *o;
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__reader1__mark(
wuffs_base__reader1* o,
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__writer1 wuffs_base__writer1__limit()
// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* o,
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){});
@@ -1195,28 +1193,28 @@ void wuffs_gif__lzw_decoder__initialize(wuffs_gif__lzw_decoder* self,
static wuffs_gif__status wuffs_gif__decoder__decode_header(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
static wuffs_gif__status wuffs_gif__decoder__decode_lsd(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
static wuffs_gif__status wuffs_gif__decoder__decode_extension(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
static wuffs_gif__status wuffs_gif__decoder__skip_blocks(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
static wuffs_gif__status wuffs_gif__decoder__decode_ae(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
static wuffs_gif__status wuffs_gif__decoder__decode_id(
wuffs_gif__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
static void wuffs_gif__lzw_decoder__set_literal_width(
wuffs_gif__lzw_decoder* self,
@@ -1224,8 +1222,8 @@ static void wuffs_gif__lzw_decoder__set_literal_width(
static wuffs_gif__status wuffs_gif__lzw_decoder__decode(
wuffs_gif__lzw_decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
// ---------------- Initializer Implementations
@@ -1270,7 +1268,7 @@ void wuffs_gif__decoder__initialize(wuffs_gif__decoder* self,
wuffs_gif__status wuffs_gif__decoder__decode_config(
wuffs_gif__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_GIF__ERROR_BAD_RECEIVER;
}
@@ -1293,7 +1291,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1318,7 +1316,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1336,7 +1334,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1368,7 +1366,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_config(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1404,7 +1402,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1426,9 +1424,10 @@ short_read_src:
goto suspend;
}
wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_gif__status wuffs_gif__decoder__decode_frame(
wuffs_gif__decoder* self,
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_GIF__ERROR_BAD_RECEIVER;
}
@@ -1447,7 +1446,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1486,7 +1485,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1505,7 +1504,7 @@ wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1549,7 +1548,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1573,7 +1572,7 @@ short_read_src:
static wuffs_gif__status wuffs_gif__decoder__decode_header(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint8_t v_c[6];
@@ -1586,7 +1585,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_header(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1641,7 +1640,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1664,7 +1663,7 @@ short_read_src:
static wuffs_gif__status wuffs_gif__decoder__decode_lsd(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint8_t v_c[7];
@@ -1678,7 +1677,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_lsd(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1766,7 +1765,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1789,7 +1788,7 @@ short_read_src:
static wuffs_gif__status wuffs_gif__decoder__decode_extension(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint8_t v_label;
@@ -1801,7 +1800,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1833,7 +1832,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1854,7 +1853,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_extension(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1885,7 +1884,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1908,7 +1907,7 @@ short_read_src:
static wuffs_gif__status wuffs_gif__decoder__skip_blocks(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint8_t v_block_size;
@@ -1920,7 +1919,7 @@ static wuffs_gif__status wuffs_gif__decoder__skip_blocks(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1979,7 +1978,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2002,7 +2001,7 @@ short_read_src:
static wuffs_gif__status wuffs_gif__decoder__decode_ae(
wuffs_gif__decoder* self,
wuffs_base__reader1 a_src) {
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint8_t v_c;
@@ -2017,7 +2016,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2170,7 +2169,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_ae(
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2204,7 +2203,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2227,8 +2226,8 @@ short_read_src:
static wuffs_gif__status wuffs_gif__decoder__decode_id(
wuffs_gif__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint8_t v_flags;
@@ -2236,7 +2235,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id(
uint32_t v_i;
uint8_t v_lw;
uint64_t v_block_size;
wuffs_base__reader1 v_r;
wuffs_base__io_reader v_r;
wuffs_gif__status v_z;
uint8_t* b_rptr_src = NULL;
@@ -2246,7 +2245,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2262,7 +2261,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id(
v_i = self->private_impl.c_decode_id[0].v_i;
v_lw = self->private_impl.c_decode_id[0].v_lw;
v_block_size = self->private_impl.c_decode_id[0].v_block_size;
v_r = ((wuffs_base__reader1){});
v_r = ((wuffs_base__io_reader){});
v_z = self->private_impl.c_decode_id[0].v_z;
} else {
}
@@ -2450,13 +2449,13 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id(
}
while (true) {
v_r = a_src;
wuffs_base__reader1__mark(&v_r, b_rptr_src);
wuffs_base__io_reader__mark(&v_r, b_rptr_src);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2466,7 +2465,7 @@ static wuffs_gif__status wuffs_gif__decoder__decode_id(
uint64_t l_rlimit0 = v_block_size;
wuffs_gif__status t_14 = wuffs_gif__lzw_decoder__decode(
&self->private_impl.f_lzw, a_dst,
wuffs_base__reader1__limit(&v_r, &l_rlimit0));
wuffs_base__io_reader__limit(&v_r, &l_rlimit0));
if (a_src.buf) {
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
}
@@ -2526,7 +2525,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2555,8 +2554,8 @@ static void wuffs_gif__lzw_decoder__set_literal_width(
static wuffs_gif__status wuffs_gif__lzw_decoder__decode(
wuffs_gif__lzw_decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
wuffs_gif__status status = WUFFS_GIF__STATUS_OK;
uint32_t v_clear_code;
@@ -2581,7 +2580,7 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode(
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2597,7 +2596,7 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode(
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -2693,7 +2692,7 @@ static wuffs_gif__status wuffs_gif__lzw_decoder__decode(
((wuffs_base__slice_u8){.ptr = self->private_impl.f_stack,
.len = 4096}),
v_s);
v_n_copied = wuffs_base__writer1__copy_from_slice(
v_n_copied = wuffs_base__io_writer__copy_from_slice(
&b_wptr_dst, b_wend_dst, v_expansion);
if (v_n_copied == ((uint64_t)(v_expansion.len))) {
goto label_1_break;
@@ -2747,7 +2746,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -2759,7 +2758,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
+45 -47
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -839,8 +837,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -944,8 +942,8 @@ void wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self,
bool a_ic);
wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -1144,9 +1142,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
static inline uint32_t wuffs_base__io_writer__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
uint8_t* start, // May be NULL, meaning an unmarked io_writer.
uint8_t* end,
uint32_t distance,
uint32_t length) {
@@ -1170,7 +1168,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
// 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.
// 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?
@@ -1186,14 +1184,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
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:
// 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__writer1__copy_from_history32__bco(
static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
@@ -1214,7 +1212,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_reader32(
static inline uint32_t wuffs_base__io_writer__copy_from_reader32(
uint8_t** ptr_wptr,
uint8_t* wend,
uint8_t** ptr_rptr,
@@ -1237,7 +1235,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32(
return n;
}
static inline uint64_t wuffs_base__writer1__copy_from_slice(
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src) {
@@ -1253,7 +1251,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__writer1__copy_from_slice32(
static inline uint32_t wuffs_base__io_writer__copy_from_slice32(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src,
@@ -1275,7 +1273,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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
// 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
@@ -1285,26 +1283,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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,
static inline wuffs_base__io_reader wuffs_base__io_reader__limit(
wuffs_base__io_reader* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 ret = *o;
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__reader1__mark(
wuffs_base__reader1* o,
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__writer1 wuffs_base__writer1__limit()
// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* o,
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){});
@@ -1408,8 +1406,8 @@ void wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self,
}
wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_GZIP__ERROR_BAD_RECEIVER;
}
@@ -1439,7 +1437,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1455,7 +1453,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1614,13 +1612,13 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
v_checksum_got = 0;
v_decoded_length_got = 0;
while (true) {
wuffs_base__writer1__mark(&a_dst, b_wptr_dst);
wuffs_base__io_writer__mark(&a_dst, b_wptr_dst);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15);
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1630,7 +1628,7 @@ wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1762,7 +1760,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1774,7 +1772,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
+45 -47
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -749,8 +747,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -870,8 +868,8 @@ void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self,
bool a_ic);
wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -1070,9 +1068,9 @@ static inline uint64_t wuffs_base__slice_u8__copy_from_slice(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_history32(
static inline uint32_t wuffs_base__io_writer__copy_from_history32(
uint8_t** ptr_ptr,
uint8_t* start, // May be NULL, meaning an unmarked writer1.
uint8_t* start, // May be NULL, meaning an unmarked io_writer.
uint8_t* end,
uint32_t distance,
uint32_t length) {
@@ -1096,7 +1094,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
// 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.
// 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?
@@ -1112,14 +1110,14 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32(
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:
// 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__writer1__copy_from_history32__bco(
static inline uint32_t wuffs_base__io_writer__copy_from_history32__bco(
uint8_t** ptr_ptr,
uint8_t* start,
uint8_t* end,
@@ -1140,7 +1138,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_history32__bco(
return length;
}
static inline uint32_t wuffs_base__writer1__copy_from_reader32(
static inline uint32_t wuffs_base__io_writer__copy_from_reader32(
uint8_t** ptr_wptr,
uint8_t* wend,
uint8_t** ptr_rptr,
@@ -1163,7 +1161,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_reader32(
return n;
}
static inline uint64_t wuffs_base__writer1__copy_from_slice(
static inline uint64_t wuffs_base__io_writer__copy_from_slice(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src) {
@@ -1179,7 +1177,7 @@ static inline uint64_t wuffs_base__writer1__copy_from_slice(
return n;
}
static inline uint32_t wuffs_base__writer1__copy_from_slice32(
static inline uint32_t wuffs_base__io_writer__copy_from_slice32(
uint8_t** ptr_wptr,
uint8_t* wend,
wuffs_base__slice_u8 src,
@@ -1201,7 +1199,7 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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
// 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
@@ -1211,26 +1209,26 @@ static inline uint32_t wuffs_base__writer1__copy_from_slice32(
// 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,
static inline wuffs_base__io_reader wuffs_base__io_reader__limit(
wuffs_base__io_reader* o,
uint64_t* ptr_to_len) {
wuffs_base__reader1 ret = *o;
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__reader1__mark(
wuffs_base__reader1* o,
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__writer1 wuffs_base__writer1__limit()
// TODO: static inline wuffs_base__io_writer wuffs_base__io_writer__limit()
static inline wuffs_base__empty_struct wuffs_base__writer1__mark(
wuffs_base__writer1* o,
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){});
@@ -1357,8 +1355,8 @@ void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self,
}
wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
if (!self) {
return WUFFS_ZLIB__ERROR_BAD_RECEIVER;
}
@@ -1384,7 +1382,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
b_wend_dst = b_wptr_dst;
if (!a_dst.buf->closed) {
uint64_t len = a_dst.buf->len - a_dst.buf->wi;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1400,7 +1398,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
b_rptr_src = a_src.buf->ptr + a_src.buf->ri;
b_rstart_src = b_rptr_src;
uint64_t len = a_src.buf->wi - a_src.buf->ri;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len && (len > *lim->ptr_to_len)) {
len = *lim->ptr_to_len;
@@ -1466,13 +1464,13 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
}
v_checksum_got = 0;
while (true) {
wuffs_base__writer1__mark(&a_dst, b_wptr_dst);
wuffs_base__io_writer__mark(&a_dst, b_wptr_dst);
{
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1482,7 +1480,7 @@ wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1569,7 +1567,7 @@ exit:
if (a_dst.buf) {
size_t n = b_wptr_dst - (a_dst.buf->ptr + a_dst.buf->wi);
a_dst.buf->wi += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_dst.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
@@ -1581,7 +1579,7 @@ exit:
if (a_src.buf) {
size_t n = b_rptr_src - (a_src.buf->ptr + a_src.buf->ri);
a_src.buf->ri += n;
wuffs_base__limit1* lim;
wuffs_base__io_limit* lim;
for (lim = &a_src.private_impl.limit; lim; lim = lim->next) {
if (lim->ptr_to_len) {
*lim->ptr_to_len -= n;
+13 -15
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
+15 -17
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -740,8 +738,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
+16 -18
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -755,11 +753,11 @@ void wuffs_gif__decoder__initialize(wuffs_gif__decoder* self,
wuffs_gif__status wuffs_gif__decoder__decode_config(
wuffs_gif__decoder* self,
wuffs_base__image_config* a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_reader a_src);
wuffs_gif__status wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
+17 -19
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -839,8 +837,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -944,8 +942,8 @@ void wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self,
bool a_ic);
wuffs_gzip__status wuffs_gzip__decoder__decode(wuffs_gzip__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
+17 -19
View File
@@ -99,9 +99,7 @@ typedef struct {
// ---------------- I/O
// TODO: rename buf1 to io_buffer, writer1 to io_writer, etc.
// wuffs_base__buf1 is a 1-dimensional buffer (a pointer and length), plus
// 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.
@@ -111,44 +109,44 @@ typedef struct {
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__io_buffer;
// wuffs_base__limit1 provides a limited view of a 1-dimensional byte stream:
// 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__limit1 {
uint64_t* ptr_to_len; // Pointer to N.
struct wuffs_base__limit1* next; // Linked list of limits.
} wuffs_base__limit1;
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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__reader1;
} 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__buf1* buf;
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__limit1 limit;
wuffs_base__io_limit limit;
uint8_t* mark;
} private_impl;
} wuffs_base__writer1;
} wuffs_base__io_writer;
// ---------------- Images
@@ -749,8 +747,8 @@ void wuffs_deflate__decoder__initialize(wuffs_deflate__decoder* self,
wuffs_deflate__status wuffs_deflate__decoder__decode(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
@@ -870,8 +868,8 @@ void wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self,
bool a_ic);
wuffs_zlib__status wuffs_zlib__decoder__decode(wuffs_zlib__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
#ifdef __cplusplus
} // extern "C"
+4 -4
View File
@@ -277,9 +277,9 @@ func (n *Raw) SetPackage(tm *t.Map, pkg t.ID) error {
// TODO: Add signed integer types, as per the builtin.Types var?
//
// Or, don't hard code these, and instead require built-in types to
// have qualified names, such as "builtin.u8" or "base.reader1"?
// have qualified names, such as "builtin.u8" or "base.io_reader"?
switch o.id2.Key() {
case t.KeyU8, t.KeyU16, t.KeyU32, t.KeyU64, t.KeyBool, t.KeyStatus, t.KeyReader1, t.KeyWriter1:
case t.KeyU8, t.KeyU16, t.KeyU32, t.KeyU64, t.KeyBool, t.KeyStatus, t.KeyIOReader, t.KeyIOWriter:
return nil
}
}
@@ -700,7 +700,7 @@ func (n *TypeExpr) IsSliceType() bool {
func (n *TypeExpr) IsUnsignedInteger() bool {
return n.id0 == 0 && (n.id2.Key() == t.KeyU8 || n.id2.Key() == t.KeyU16 ||
n.id2.Key() == t.KeyU32 || n.id2.Key() == t.KeyU64) // TODO: t.KeyUsize?
n.id2.Key() == t.KeyU32 || n.id2.Key() == t.KeyU64)
}
func (n *TypeExpr) HasPointers() bool {
@@ -708,7 +708,7 @@ func (n *TypeExpr) HasPointers() bool {
switch n.id0.Key() {
case 0:
switch n.id2.Key() {
case t.KeyBuf1, t.KeyReader1, t.KeyWriter1, t.KeyBuf2:
case t.KeyIOReader, t.KeyIOWriter:
return true
}
case t.KeyPtr, t.KeyNptr, t.KeyColon:
+33 -33
View File
@@ -71,8 +71,8 @@ var Types = []string{
"u64",
"bool",
"status",
"reader1",
"writer1",
"io_reader",
"io_writer",
"image_config",
}
@@ -92,40 +92,40 @@ var Funcs = []string{
"status.is_ok()(ret bool)",
"status.is_suspension()(ret bool)",
"reader1.read_u8?()(ret u8)",
"reader1.read_u16be?()(ret u16)",
"reader1.read_u16le?()(ret u16)",
"reader1.read_u32be?()(ret u32)",
"reader1.read_u32le?()(ret u32)",
"reader1.read_u64be?()(ret u64)",
"reader1.read_u64le?()(ret u64)",
"io_reader.read_u8?()(ret u8)",
"io_reader.read_u16be?()(ret u16)",
"io_reader.read_u16le?()(ret u16)",
"io_reader.read_u32be?()(ret u32)",
"io_reader.read_u32le?()(ret u32)",
"io_reader.read_u64be?()(ret u64)",
"io_reader.read_u64le?()(ret u64)",
"reader1.available()(ret u64)",
"reader1.is_marked()(ret bool)",
"reader1.limit(l u64)(ret reader1)",
"reader1.mark()()",
"reader1.since_mark()(ret[] u8)",
"reader1.skip32?(n u32)()",
"reader1.skip64?(n u64)()",
"reader1.unread_u8?()()",
"io_reader.available()(ret u64)",
"io_reader.is_marked()(ret bool)",
"io_reader.limit(l u64)(ret io_reader)",
"io_reader.mark()()",
"io_reader.since_mark()(ret[] u8)",
"io_reader.skip32?(n u32)()",
"io_reader.skip64?(n u64)()",
"io_reader.unread_u8?()()",
"writer1.write_u8?(x u8)()",
"writer1.write_u16be?(x u16)()",
"writer1.write_u16le?(x u16)()",
"writer1.write_u32be?(x u32)()",
"writer1.write_u32le?(x u32)()",
"writer1.write_u64be?(x u64)()",
"writer1.write_u64le?(x u64)()",
"io_writer.write_u8?(x u8)()",
"io_writer.write_u16be?(x u16)()",
"io_writer.write_u16le?(x u16)()",
"io_writer.write_u32be?(x u32)()",
"io_writer.write_u32le?(x u32)()",
"io_writer.write_u64be?(x u64)()",
"io_writer.write_u64le?(x u64)()",
"writer1.available()(ret u64)",
"writer1.copy_from_history32(distance u32, length u32)(ret u32)",
"writer1.copy_from_reader32(r reader1, length u32)(ret u32)",
"writer1.copy_from_slice(s[] u8)(ret u64)",
"writer1.copy_from_slice32(s[] u8, length u32)(ret u32)",
"writer1.is_marked()(ret bool)",
"writer1.limit(l u64)(ret writer1)",
"writer1.mark()()",
"writer1.since_mark()(ret[] u8)",
"io_writer.available()(ret u64)",
"io_writer.copy_from_history32(distance u32, length u32)(ret u32)",
"io_writer.copy_from_reader32(r io_reader, length u32)(ret u32)",
"io_writer.copy_from_slice(s[] u8)(ret u64)",
"io_writer.copy_from_slice32(s[] u8, length u32)(ret u32)",
"io_writer.is_marked()(ret bool)",
"io_writer.limit(l u64)(ret io_writer)",
"io_writer.mark()()",
"io_writer.since_mark()(ret[] u8)",
"image_config.initialize!(pixfmt u32, pixsub u32, width u32, height u32, num_loops u32)()",
}
+12 -13
View File
@@ -23,16 +23,15 @@ import (
)
var numTypeBounds = [256][2]*big.Int{
t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
t.KeyUsize: {zero, zero},
t.KeyBool: {zero, one},
t.KeyI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
t.KeyI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
t.KeyI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
t.KeyI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
t.KeyU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
t.KeyU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
t.KeyU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
t.KeyU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
t.KeyBool: {zero, one},
}
var (
@@ -1192,11 +1191,11 @@ func (q *checker) bcheckTypeExpr(typ *a.TypeExpr) (*big.Int, *big.Int, error) {
return nil, nil, nil
}
// TODO: is the special cases for reader1 and writer1 superfluous with the
// general purpose code for built-ins below?
// TODO: is the special cases for io_reader and io_writer superfluous with
// the general purpose code for built-ins below?
if qid := typ.QID(); qid[0] == 0 {
switch qid[1].Key() {
case t.KeyReader1, t.KeyWriter1:
case t.KeyIOReader, t.KeyIOWriter:
return nil, nil, nil
}
}
+2 -2
View File
@@ -60,7 +60,7 @@ func (q *checker) optimizeNonSuspendible(n *a.Expr) error {
return nil
}
// TODO: check that nReceiver's type is actually a reader1 or writer1.
// TODO: check that nReceiver's type is actually a io_reader or io_writer.
switch nMethod {
case t.KeyCopyFromHistory32:
@@ -225,7 +225,7 @@ func (q *checker) optimizeSuspendible(n *a.Expr, depth uint32) error {
return nil
}
// TODO: check that nReceiver's type is actually a reader1 or writer1.
// TODO: check that nReceiver's type is actually a io_reader or io_writer.
if nMethod == t.KeyUnreadU8 {
// unread_u8 can never suspend, only succeed or fail.
+4 -4
View File
@@ -44,8 +44,8 @@ var (
typeExprU64 = a.NewTypeExpr(0, 0, t.IDU64, nil, nil, nil)
typeExprBool = a.NewTypeExpr(0, 0, t.IDBool, nil, nil, nil)
typeExprStatus = a.NewTypeExpr(0, 0, t.IDStatus, nil, nil, nil)
typeExprReader1 = a.NewTypeExpr(0, 0, t.IDReader1, nil, nil, nil)
typeExprWriter1 = a.NewTypeExpr(0, 0, t.IDWriter1, nil, nil, nil)
typeExprIOReader = a.NewTypeExpr(0, 0, t.IDIOReader, nil, nil, nil)
typeExprIOWriter = a.NewTypeExpr(0, 0, t.IDIOWriter, nil, nil, nil)
typeExprImageConfig = a.NewTypeExpr(0, 0, t.IDImageConfig, nil, nil, nil)
typeExprSliceU8 = a.NewTypeExpr(t.IDColon, 0, 0, nil, nil, typeExprU8)
@@ -66,8 +66,8 @@ var builtInTypeMap = typeMap{
t.IDU64: typeExprU64,
t.IDBool: typeExprBool,
t.IDStatus: typeExprStatus,
t.IDReader1: typeExprReader1,
t.IDWriter1: typeExprWriter1,
t.IDIOReader: typeExprIOReader,
t.IDIOWriter: typeExprIOWriter,
t.IDImageConfig: typeExprImageConfig,
}
+9 -18
View File
@@ -282,12 +282,9 @@ const (
KeyU16 = Key(IDU16 >> KeyShift)
KeyU32 = Key(IDU32 >> KeyShift)
KeyU64 = Key(IDU64 >> KeyShift)
KeyUsize = Key(IDUsize >> KeyShift) // TODO: unused?
KeyBool = Key(IDBool >> KeyShift)
KeyBuf1 = Key(IDBuf1 >> KeyShift) // TODO: unused?
KeyReader1 = Key(IDReader1 >> KeyShift)
KeyWriter1 = Key(IDWriter1 >> KeyShift)
KeyBuf2 = Key(IDBuf2 >> KeyShift) // TODO: unused?
KeyIOReader = Key(IDIOReader >> KeyShift)
KeyIOWriter = Key(IDIOWriter >> KeyShift)
KeyStatus = Key(IDStatus >> KeyShift)
KeyImageConfig = Key(IDImageConfig >> KeyShift)
@@ -474,14 +471,11 @@ const (
IDU16 = ID(0x85<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
IDU32 = ID(0x86<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
IDU64 = ID(0x87<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
IDUsize = ID(0x88<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
IDBool = ID(0x89<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDBuf1 = ID(0x8A<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDReader1 = ID(0x8B<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDWriter1 = ID(0x8C<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDBuf2 = ID(0x8D<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDStatus = ID(0x8E<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDImageConfig = ID(0x8F<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDBool = ID(0x88<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDIOReader = ID(0x89<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDIOWriter = ID(0x8A<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDStatus = ID(0x8B<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDImageConfig = ID(0x8C<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDMark = ID(0x90<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
IDReadU8 = ID(0x91<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
@@ -688,12 +682,9 @@ var builtInsByKey = [nBuiltInKeys]struct {
KeyU16: {"u16", IDU16},
KeyU32: {"u32", IDU32},
KeyU64: {"u64", IDU64},
KeyUsize: {"usize", IDUsize},
KeyBool: {"bool", IDBool},
KeyBuf1: {"buf1", IDBuf1},
KeyReader1: {"reader1", IDReader1},
KeyWriter1: {"writer1", IDWriter1},
KeyBuf2: {"buf2", IDBuf2},
KeyIOReader: {"io_reader", IDIOReader},
KeyIOWriter: {"io_writer", IDIOWriter},
KeyStatus: {"status", IDStatus},
KeyImageConfig: {"image_config", IDImageConfig},
@@ -120,14 +120,14 @@ static const uint32_t wuffs_base__width_to_mask_table[33] = {
// the function name is "wuffs_etc", not "c_wuffs_etc".
static wuffs_deflate__status wuffs_deflate__decoder__decode_huffman_fast(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src);
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src);
// This is the overriding implementation.
wuffs_deflate__status c_wuffs_deflate__decoder__decode_huffman_fast(
wuffs_deflate__decoder* self,
wuffs_base__writer1 a_dst,
wuffs_base__reader1 a_src) {
wuffs_base__io_writer a_dst,
wuffs_base__io_reader a_src) {
// Avoid the -Werror=unused-function warning for the now-unused
// overridden wuffs_deflate__decoder__decode_huffman_fast.
(void)(wuffs_deflate__decoder__decode_huffman_fast);
+4 -4
View File
@@ -121,7 +121,7 @@ pub struct decoder?(
end_of_block bool,
)
pub func decoder.decode?(dst writer1, src reader1)() {
pub func decoder.decode?(dst io_writer, src io_reader)() {
while true {
in.dst.mark()
var z status = try this.decode_blocks?(dst:in.dst, src:in.src)
@@ -173,7 +173,7 @@ pub func decoder.decode?(dst writer1, src reader1)() {
}
}
pri func decoder.decode_blocks?(dst writer1, src reader1)() {
pri func decoder.decode_blocks?(dst io_writer, src io_reader)() {
var final u32
while final == 0 {
while this.n_bits < 3,
@@ -213,7 +213,7 @@ pri func decoder.decode_blocks?(dst writer1, src reader1)() {
// decode_uncompressed decodes an uncompresed block as per the RFC section
// 3.2.4.
pri func decoder.decode_uncompressed?(dst writer1, src reader1)() {
pri func decoder.decode_uncompressed?(dst io_writer, src io_reader)() {
// TODO: make this "if" into a function invariant?
//
// Ditto for decode_huffman_slow and decode_huffman_fast.
@@ -272,7 +272,7 @@ pri func decoder.init_fixed_huffman?()() {
}
// init_dynamic_huffman initializes this.huffs as per the RFC section 3.2.7.
pri func decoder.init_dynamic_huffman?(src reader1)() {
pri func decoder.init_dynamic_huffman?(src io_reader)() {
var bits u32 = this.bits
var n_bits u32 = this.n_bits
while n_bits < 14,
+1 -1
View File
@@ -14,7 +14,7 @@
// TODO: describe how the xxx_fast version differs from the xxx_slow one, the
// assumptions that xxx_fast makes, and how that makes it fast.
pri func decoder.decode_huffman_fast?(dst writer1, src reader1)() {
pri func decoder.decode_huffman_fast?(dst io_writer, src io_reader)() {
// When editing this function, consider making the equivalent change to the
// decode_huffman_slow function. Keep the diff between the two
// decode_huffman_*.wuffs files as small as possible, while retaining both
+1 -1
View File
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
pri func decoder.decode_huffman_slow?(dst writer1, src reader1)() {
pri func decoder.decode_huffman_slow?(dst io_writer, src io_reader)() {
// When editing this function, consider making the equivalent change to the
// decode_huffman_fast function. Keep the diff between the two
// decode_huffman_*.wuffs files as small as possible, while retaining both
+10 -10
View File
@@ -60,7 +60,7 @@ pub struct decoder?(
)
// TODO: should dst be an nptr instead of a ptr?
pub func decoder.decode_config?(dst ptr image_config, src reader1)() {
pub func decoder.decode_config?(dst ptr image_config, src io_reader)() {
if this.call_sequence >= 1 {
return error "invalid call sequence"
}
@@ -85,7 +85,7 @@ pub func decoder.decode_config?(dst ptr image_config, src reader1)() {
this.call_sequence = 1
}
pub func decoder.decode_frame?(dst writer1, src reader1)() {
pub func decoder.decode_frame?(dst io_writer, src io_reader)() {
if this.call_sequence < 1 {
return error "invalid call sequence"
}
@@ -121,7 +121,7 @@ pub func decoder.decode_frame?(dst writer1, src reader1)() {
// decode_header reads either "GIF87a" or "GIF89a".
//
// See the spec section 17 "Header" on page 7.
pri func decoder.decode_header?(src reader1)() {
pri func decoder.decode_header?(src io_reader)() {
var c[6] u8
var i u32
while i < 6 {
@@ -137,7 +137,7 @@ pri func decoder.decode_header?(src reader1)() {
// decode_lsd reads the Logical Screen Descriptor.
//
// See the spec section 18 "Logical Screen Descriptor" on page 8.
pri func decoder.decode_lsd?(src reader1)() {
pri func decoder.decode_lsd?(src io_reader)() {
var c[7] u8
var i u32
while i < 7 {
@@ -172,7 +172,7 @@ pri func decoder.decode_lsd?(src reader1)() {
// - section 24 "Comment Extension" on page 17.
// - section 25 "Plain Text Extension" on page 18.
// - section 26 "Application Extension" on page 21.
pri func decoder.decode_extension?(src reader1)() {
pri func decoder.decode_extension?(src io_reader)() {
var label u8 = in.src.read_u8?()
if label == 0xF9 { // The spec calls 0xF9 the "Graphic Control Label".
// TODO.
@@ -185,7 +185,7 @@ pri func decoder.decode_extension?(src reader1)() {
this.skip_blocks?(src:in.src)
}
pri func decoder.skip_blocks?(src reader1)() {
pri func decoder.skip_blocks?(src io_reader)() {
while true {
var block_size u8 = in.src.read_u8?()
if block_size == 0 {
@@ -206,7 +206,7 @@ pri const netscape2dot0[11] u8 = $(
)
// decode_ae reads an Application Extension.
pri func decoder.decode_ae?(src reader1)() {
pri func decoder.decode_ae?(src io_reader)() {
// This "while true" always executes exactly once, as it ends with a
// "break", but using "break"s throughout simplifies the control flow.
while true {
@@ -275,7 +275,7 @@ pri func decoder.decode_ae?(src reader1)() {
// been read.
//
// See the spec section 20 "Image Descriptor" on page 11.
pri func decoder.decode_id?(dst writer1, src reader1)() {
pri func decoder.decode_id?(dst io_writer, src io_reader)() {
// TODO: check that the frame rect is inside the image rect??
this.frame_left = in.src.read_u16le?() as u32
this.frame_top = in.src.read_u16le?() as u32
@@ -312,9 +312,9 @@ pri func decoder.decode_id?(dst writer1, src reader1)() {
break
}
while true {
var r reader1 = in.src
var r io_reader = in.src
// TODO: should "mark" be "set_mark"? Unlike "limit", "mark" does
// not return a different reader1.
// not return a different io_reader.
r.mark()
// TODO: remove the dummy param. It's needed for now so that
// writeSaveExprDerivedVars updates e.g. the b_rptr_src derived
+1 -1
View File
@@ -28,7 +28,7 @@ pri func lzw_decoder.set_literal_width!(lw u32[2..8] = 8)() {
this.literal_width = in.lw
}
pri func lzw_decoder.decode?(dst writer1, src reader1)() {
pri func lzw_decoder.decode?(dst io_writer, src io_reader)() {
// These variables don't change over the lifetime of this func.
var clear_code u32[4..256] = (1 as u32) << this.literal_width
var end_code u32[5..257] = clear_code + 1
+1 -1
View File
@@ -32,7 +32,7 @@ pub func decoder.set_ignore_checksum!(ic bool)() {
this.ignore_checksum = in.ic
}
pub func decoder.decode?(dst writer1, src reader1)() {
pub func decoder.decode?(dst io_writer, src io_reader)() {
// Read the header.
if in.src.read_u8?() != 0x1F {
return error "bad gzip header"
+1 -1
View File
@@ -33,7 +33,7 @@ pub func decoder.set_ignore_checksum!(ic bool)() {
this.ignore_checksum = in.ic
}
pub func decoder.decode?(dst writer1, src reader1)() {
pub func decoder.decode?(dst io_writer, src io_reader)() {
var x u16 = in.src.read_u16be?()
if ((x >> 8) & 0x0F) != 0x08 {
return error "invalid zlib compression method"
+24 -24
View File
@@ -18,22 +18,22 @@
#ifdef WUFFS_MIMICLIB_USE_MINIZ_INSTEAD_OF_ZLIB
#include "/path/to/your/copy/of/github.com/richgel999/miniz/miniz_tinfl.c"
const char* mimic_bench_adler32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_bench_adler32(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return "miniz does not independently compute Adler32";
}
const char* mimic_bench_crc32_ieee(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return "miniz does not implement CRC32/IEEE";
}
const char* mimic_deflate_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit,
bool deflate_instead_of_zlib) {
@@ -53,22 +53,22 @@ const char* mimic_deflate_zlib_decode(wuffs_base__buf1* dst,
return NULL;
}
const char* mimic_deflate_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_zlib_decode(dst, src, wlimit, rlimit, true);
}
const char* mimic_gzip_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return "miniz does not implement gzip";
}
const char* mimic_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_zlib_decode(dst, src, wlimit, rlimit, false);
@@ -79,8 +79,8 @@ const char* mimic_zlib_decode(wuffs_base__buf1* dst,
uint32_t global_mimiclib_deflate_unused_u32;
const char* mimic_bench_adler32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_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.
@@ -94,8 +94,8 @@ const char* mimic_bench_adler32(wuffs_base__buf1* dst,
return NULL;
}
const char* mimic_bench_crc32_ieee(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
@@ -115,8 +115,8 @@ typedef enum {
zlib_flavor_zlib,
} zlib_flavor;
const char* mimic_deflate_gzip_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit,
zlib_flavor flavor) {
@@ -184,24 +184,24 @@ cleanup0:;
return ret;
}
const char* mimic_deflate_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_gzip_zlib_decode(dst, src, wlimit, rlimit,
zlib_flavor_raw);
}
const char* mimic_gzip_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_gzip_zlib_decode(dst, src, wlimit, rlimit,
zlib_flavor_gzip);
}
const char* mimic_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* mimic_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
return mimic_deflate_gzip_zlib_decode(dst, src, wlimit, rlimit,
+3 -2
View File
@@ -15,7 +15,7 @@
#include "gif_lib.h"
int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
wuffs_base__buf1* src = (wuffs_base__buf1*)(f->UserData);
wuffs_base__io_buffer* src = (wuffs_base__io_buffer*)(f->UserData);
if (len < 0) {
return 0;
}
@@ -29,7 +29,8 @@ int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
return n;
}
const char* mimic_gif_decode(wuffs_base__buf1* dst, wuffs_base__buf1* src) {
const char* mimic_gif_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src) {
const char* ret = NULL;
// http://giflib.sourceforge.net/gif_lib.html#compatibility says that "A few
+11 -9
View File
@@ -98,7 +98,7 @@ void test_wuffs_crc32_ieee_golden() {
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, test_cases[i].filename)) {
return;
}
@@ -165,8 +165,8 @@ void test_wuffs_crc32_ieee_pi() {
uint32_t global_wuffs_crc32_unused_u32;
const char* wuffs_bench_crc32_ieee(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
@@ -183,13 +183,14 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__buf1* dst,
void bench_wuffs_crc32_ieee_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0,
150000);
do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0,
150000);
}
void bench_wuffs_crc32_ieee_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, 15000);
do_bench_io_buffers(wuffs_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0,
15000);
}
// ---------------- Mimic Benches
@@ -198,13 +199,14 @@ void bench_wuffs_crc32_ieee_100k() {
void bench_mimic_crc32_ieee_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0,
150000);
do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_midsummer_gt, 0, 0,
150000);
}
void bench_mimic_crc32_ieee_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0, 15000);
do_bench_io_buffers(mimic_bench_crc32_ieee, tc_src, &crc32_pi_gt, 0, 0,
15000);
}
#endif // WUFFS_MIMIC
+53 -53
View File
@@ -107,8 +107,8 @@ golden_test deflate_romeo_fixed_gt = {
// ---------------- Deflate Tests
const char* wuffs_deflate_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_deflate__decoder dec;
@@ -116,12 +116,12 @@ const char* wuffs_deflate_decode(wuffs_base__buf1* dst,
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
wuffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__io_writer dst_writer = {.buf = dst};
if (wlimit) {
wlim = wlimit;
dst_writer.private_impl.limit.ptr_to_len = &wlim;
}
wuffs_base__reader1 src_reader = {.buf = src};
wuffs_base__io_reader src_reader = {.buf = src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -143,62 +143,62 @@ const char* wuffs_deflate_decode(wuffs_base__buf1* dst,
void test_wuffs_deflate_decode_256_bytes() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0);
do_test_io_buffers(wuffs_deflate_decode, &deflate_256_bytes_gt, 0, 0);
}
void test_wuffs_deflate_decode_deflate_backref_crosses_blocks() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode,
&deflate_deflate_backref_crosses_blocks_gt, 0, 0);
do_test_io_buffers(wuffs_deflate_decode,
&deflate_deflate_backref_crosses_blocks_gt, 0, 0);
}
void test_wuffs_deflate_decode_deflate_distance_32768() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_deflate_distance_32768_gt, 0,
0);
do_test_io_buffers(wuffs_deflate_decode, &deflate_deflate_distance_32768_gt,
0, 0);
}
void test_wuffs_deflate_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0);
do_test_io_buffers(wuffs_deflate_decode, &deflate_midsummer_gt, 0, 0);
}
void test_wuffs_deflate_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 0);
do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 0);
}
void test_wuffs_deflate_decode_pi_many_big_reads() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096);
do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 4096);
}
void test_wuffs_deflate_decode_pi_many_medium_reads() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 0, 599);
do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 0, 599);
}
void test_wuffs_deflate_decode_pi_many_small_writes_reads() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_pi_gt, 59, 61);
do_test_io_buffers(wuffs_deflate_decode, &deflate_pi_gt, 59, 61);
}
void test_wuffs_deflate_decode_romeo() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0);
do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_gt, 0, 0);
}
void test_wuffs_deflate_decode_romeo_fixed() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, 0);
do_test_io_buffers(wuffs_deflate_decode, &deflate_romeo_fixed_gt, 0, 0);
}
void test_wuffs_deflate_decode_split_src() {
CHECK_FOCUS(__func__);
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
golden_test* gt = &deflate_256_bytes_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -209,8 +209,8 @@ void test_wuffs_deflate_decode_split_src() {
}
wuffs_deflate__decoder dec;
wuffs_base__writer1 dst_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_writer dst_writer = {.buf = &got};
wuffs_base__io_reader src_reader = {.buf = &src};
int i;
for (i = 1; i < 32; i++) {
@@ -252,7 +252,7 @@ void test_wuffs_deflate_decode_split_src() {
char prefix[64];
snprintf(prefix, 64, "i=%d: ", i);
if (!buf1s_equal(prefix, &got, &want)) {
if (!io_buffers_equal(prefix, &got, &want)) {
return;
}
}
@@ -260,8 +260,8 @@ void test_wuffs_deflate_decode_split_src() {
bool do_test_wuffs_deflate_history(int i,
golden_test* gt,
wuffs_base__buf1* src,
wuffs_base__buf1* got,
wuffs_base__io_buffer* src,
wuffs_base__io_buffer* got,
wuffs_deflate__decoder* dec,
uint32_t starting_history_index,
uint64_t limit,
@@ -272,8 +272,8 @@ bool do_test_wuffs_deflate_history(int i,
got->wi = 0;
wuffs_deflate__decoder__initialize(dec, WUFFS_VERSION, 0);
wuffs_base__writer1 dst_writer = {.buf = got};
wuffs_base__reader1 src_reader = {.buf = src};
wuffs_base__io_writer dst_writer = {.buf = got};
wuffs_base__io_reader src_reader = {.buf = src};
dec->private_impl.f_history_index = starting_history_index;
@@ -294,9 +294,9 @@ bool do_test_wuffs_deflate_history(int i,
void test_wuffs_deflate_history_full() {
CHECK_FOCUS(__func__);
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
golden_test* gt = &deflate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -327,7 +327,7 @@ void test_wuffs_deflate_history_full() {
continue;
}
wuffs_base__buf1 history_got = {
wuffs_base__io_buffer history_got = {
.ptr = dec.private_impl.f_history,
.len = full_history_size,
.wi = full_history_size,
@@ -336,12 +336,12 @@ void test_wuffs_deflate_history_full() {
FAIL("i=%d: want file is too short", i);
return;
}
wuffs_base__buf1 history_want = {
wuffs_base__io_buffer history_want = {
.ptr = global_want_buffer + want.wi - (full_history_size - i),
.len = full_history_size,
.wi = full_history_size,
};
if (!buf1s_equal("", &history_got, &history_want)) {
if (!io_buffers_equal("", &history_got, &history_want)) {
return;
}
}
@@ -350,8 +350,8 @@ void test_wuffs_deflate_history_full() {
void test_wuffs_deflate_history_partial() {
CHECK_FOCUS(__func__);
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
golden_test* gt = &deflate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -544,39 +544,39 @@ void test_wuffs_deflate_table_redirect() {
void test_mimic_deflate_decode_256_bytes() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0);
do_test_io_buffers(mimic_deflate_decode, &deflate_256_bytes_gt, 0, 0);
}
void test_mimic_deflate_decode_deflate_backref_crosses_blocks() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode,
&deflate_deflate_backref_crosses_blocks_gt, 0, 0);
do_test_io_buffers(mimic_deflate_decode,
&deflate_deflate_backref_crosses_blocks_gt, 0, 0);
}
void test_mimic_deflate_decode_deflate_distance_32768() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode, &deflate_deflate_distance_32768_gt, 0,
0);
do_test_io_buffers(mimic_deflate_decode, &deflate_deflate_distance_32768_gt,
0, 0);
}
void test_mimic_deflate_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0);
do_test_io_buffers(mimic_deflate_decode, &deflate_midsummer_gt, 0, 0);
}
void test_mimic_deflate_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode, &deflate_pi_gt, 0, 0);
do_test_io_buffers(mimic_deflate_decode, &deflate_pi_gt, 0, 0);
}
void test_mimic_deflate_decode_romeo() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_gt, 0, 0);
do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_gt, 0, 0);
}
void test_mimic_deflate_decode_romeo_fixed() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0);
do_test_io_buffers(mimic_deflate_decode, &deflate_romeo_fixed_gt, 0, 0);
}
#endif // WUFFS_MIMIC
@@ -585,19 +585,19 @@ void test_mimic_deflate_decode_romeo_fixed() {
void bench_wuffs_deflate_decode_1k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0,
200000);
do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0,
200000);
}
void bench_wuffs_deflate_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0,
30000);
do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0,
30000);
}
void bench_wuffs_deflate_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000);
do_bench_io_buffers(wuffs_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000);
}
// ---------------- Mimic Benches
@@ -606,19 +606,19 @@ void bench_wuffs_deflate_decode_100k() {
void bench_mimic_deflate_decode_1k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0,
200000);
do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_romeo_gt, 0, 0,
200000);
}
void bench_mimic_deflate_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0,
30000);
do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_midsummer_gt, 0, 0,
30000);
}
void bench_mimic_deflate_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000);
do_bench_io_buffers(mimic_deflate_decode, tc_dst, &deflate_pi_gt, 0, 0, 3000);
}
#endif // WUFFS_MIMIC
+49 -45
View File
@@ -51,7 +51,7 @@ the first "./a.out" with "./a.out -bench". Combine these changes with the
void test_basic_bad_receiver() {
CHECK_FOCUS(__func__);
wuffs_base__image_config ic = {{0}};
wuffs_base__reader1 src = {0};
wuffs_base__io_reader src = {0};
wuffs_gif__status status = wuffs_gif__decoder__decode_config(NULL, &ic, src);
if (status != WUFFS_GIF__ERROR_BAD_RECEIVER) {
FAIL("decode_config: got %d, want %d", status,
@@ -63,7 +63,7 @@ void test_basic_initializer_not_called() {
CHECK_FOCUS(__func__);
wuffs_gif__decoder dec = {{0}};
wuffs_base__image_config ic = {{0}};
wuffs_base__reader1 src = {0};
wuffs_base__io_reader src = {0};
wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src);
if (status != WUFFS_GIF__ERROR_INITIALIZER_NOT_CALLED) {
FAIL("decode_config: got %d, want %d", status,
@@ -177,9 +177,9 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
uint64_t want_size,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, src_filename)) {
return false;
@@ -212,12 +212,12 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
uint64_t rlim = 0;
while (true) {
num_iters++;
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__io_writer got_writer = {.buf = &got};
if (wlimit) {
wlim = wlimit;
got_writer.private_impl.limit.ptr_to_len = &wlim;
}
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -272,7 +272,7 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
}
}
return buf1s_equal("", &got, &want);
return io_buffers_equal("", &got, &want);
}
void test_wuffs_lzw_decode_many_big_reads() {
@@ -308,10 +308,10 @@ void test_wuffs_lzw_decode_pi() {
// ---------------- LZW Benches
bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t reps) {
wuffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__writer1 dst_writer = {.buf = &dst};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_buffer dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_writer dst_writer = {.buf = &dst};
wuffs_base__io_reader src_reader = {.buf = &src};
if (!read_file(&src, filename)) {
return false;
@@ -358,12 +358,13 @@ void bench_wuffs_lzw_decode_100k() {
// ---------------- GIF Tests
const char* wuffs_gif_decode(wuffs_base__buf1* dst, wuffs_base__buf1* src) {
const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src) {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__image_config ic = {{0}};
wuffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__reader1 src_reader = {.buf = src};
wuffs_base__io_writer dst_writer = {.buf = dst};
wuffs_base__io_reader src_reader = {.buf = src};
wuffs_gif__status s =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
if (s) {
@@ -381,8 +382,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
const char* indexes_filename,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, filename)) {
return false;
@@ -393,7 +394,7 @@ bool do_test_wuffs_gif_decode(const char* filename,
{
wuffs_base__image_config ic = {{0}};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_gif__status status =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
if (status != WUFFS_GIF__STATUS_OK) {
@@ -432,12 +433,12 @@ bool do_test_wuffs_gif_decode(const char* filename,
uint64_t rlim = 0;
while (true) {
num_iters++;
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__io_writer got_writer = {.buf = &got};
if (wlimit) {
wlim = wlimit;
got_writer.private_impl.limit.ptr_to_len = &wlim;
}
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -489,21 +490,24 @@ bool do_test_wuffs_gif_decode(const char* filename,
}
// TODO: provide a public API for getting the palette.
wuffs_base__buf1 pal_got = {.ptr = dec.private_impl.f_gct, .len = 3 * 256};
wuffs_base__buf1 pal_want = {.ptr = global_palette_buffer, .len = 3 * 256};
wuffs_base__io_buffer pal_got = {.ptr = dec.private_impl.f_gct,
.len = 3 * 256};
wuffs_base__io_buffer pal_want = {.ptr = global_palette_buffer,
.len = 3 * 256};
pal_got.wi = 3 * 256;
if (!read_file(&pal_want, palette_filename)) {
return false;
}
if (!buf1s_equal("palette ", &pal_got, &pal_want)) {
if (!io_buffers_equal("palette ", &pal_got, &pal_want)) {
return false;
}
wuffs_base__buf1 ind_want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer ind_want = {.ptr = global_want_buffer,
.len = BUFFER_SIZE};
if (!read_file(&ind_want, indexes_filename)) {
return false;
}
if (!buf1s_equal("indexes ", &got, &ind_want)) {
if (!io_buffers_equal("indexes ", &got, &ind_want)) {
return false;
}
@@ -512,8 +516,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
FAIL("decode_frame returned \"ok\" but src was exhausted");
return false;
}
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_writer got_writer = {.buf = &got};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_gif__status status =
wuffs_gif__decoder__decode_frame(&dec, got_writer, src_reader);
if (status != WUFFS_GIF__SUSPENSION_END_OF_DATA) {
@@ -534,8 +538,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
void test_wuffs_gif_call_sequence() {
CHECK_FOCUS(__func__);
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, "../../data/bricks-dither.gif")) {
return;
@@ -544,8 +548,8 @@ void test_wuffs_gif_call_sequence() {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_writer got_writer = {.buf = &got};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_gif__status status =
wuffs_gif__decoder__decode_frame(&dec, got_writer, src_reader);
@@ -561,8 +565,8 @@ void test_wuffs_gif_call_sequence() {
void test_wuffs_gif_decode_animated() {
CHECK_FOCUS(__func__);
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, "../../data/animated-red-blue.gif")) {
return;
@@ -572,8 +576,8 @@ void test_wuffs_gif_decode_animated() {
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__image_config ic = {{0}};
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_writer got_writer = {.buf = &got};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_gif__status status =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
@@ -657,7 +661,7 @@ void test_wuffs_gif_decode_input_is_a_gif_many_small_writes_reads() {
void test_wuffs_gif_decode_input_is_a_png() {
CHECK_FOCUS(__func__);
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, "../../data/bricks-dither.png")) {
return;
@@ -666,7 +670,7 @@ void test_wuffs_gif_decode_input_is_a_png() {
wuffs_gif__decoder dec;
wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_base__image_config ic = {{0}};
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
wuffs_gif__status status =
wuffs_gif__decoder__decode_config(&dec, &ic, src_reader);
@@ -683,13 +687,13 @@ void test_wuffs_gif_decode_input_is_a_png() {
#ifdef WUFFS_MIMIC
bool do_test_mimic_gif_decode(const char* filename) {
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, filename)) {
return false;
}
src.ri = 0;
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
const char* got_msg = wuffs_gif_decode(&got, &src);
if (got_msg) {
FAIL("%s", got_msg);
@@ -697,14 +701,14 @@ bool do_test_mimic_gif_decode(const char* filename) {
}
src.ri = 0;
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
const char* want_msg = mimic_gif_decode(&want, &src);
if (want_msg) {
FAIL("%s", want_msg);
return false;
}
if (!buf1s_equal("", &got, &want)) {
if (!io_buffers_equal("", &got, &want)) {
return false;
}
@@ -752,12 +756,12 @@ void test_mimic_gif_decode_pjw_thumbnail() {
// ---------------- GIF Benches
bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__buf1*,
wuffs_base__buf1*),
bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*,
wuffs_base__io_buffer*),
const char* filename,
uint64_t reps) {
wuffs_base__buf1 dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer dst = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, filename)) {
return false;
+18 -18
View File
@@ -62,8 +62,8 @@ golden_test gzip_pi_gt = {
// ---------------- Gzip Tests
const char* wuffs_gzip_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_gzip__decoder dec;
@@ -72,12 +72,12 @@ const char* wuffs_gzip_decode(wuffs_base__buf1* dst,
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
wuffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__io_writer dst_writer = {.buf = dst};
if (wlimit) {
wlim = wlimit;
dst_writer.private_impl.limit.ptr_to_len = &wlim;
}
wuffs_base__reader1 src_reader = {.buf = src};
wuffs_base__io_reader src_reader = {.buf = src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -98,8 +98,8 @@ const char* wuffs_gzip_decode(wuffs_base__buf1* dst,
}
bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, gzip_midsummer_gt.src_filename)) {
return false;
@@ -120,9 +120,9 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
wuffs_gzip__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.wi = 0;
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__io_writer got_writer = {.buf = &got};
src.ri = 0;
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
// or isn't zero.
@@ -182,12 +182,12 @@ void test_wuffs_gzip_checksum_verify_good() {
void test_wuffs_gzip_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0);
do_test_io_buffers(wuffs_gzip_decode, &gzip_midsummer_gt, 0, 0);
}
void test_wuffs_gzip_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_gzip_decode, &gzip_pi_gt, 0, 0);
do_test_io_buffers(wuffs_gzip_decode, &gzip_pi_gt, 0, 0);
}
// ---------------- Mimic Tests
@@ -196,12 +196,12 @@ void test_wuffs_gzip_decode_pi() {
void test_mimic_gzip_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0);
do_test_io_buffers(mimic_gzip_decode, &gzip_midsummer_gt, 0, 0);
}
void test_mimic_gzip_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_gzip_decode, &gzip_pi_gt, 0, 0);
do_test_io_buffers(mimic_gzip_decode, &gzip_pi_gt, 0, 0);
}
#endif // WUFFS_MIMIC
@@ -210,13 +210,13 @@ void test_mimic_gzip_decode_pi() {
void bench_wuffs_gzip_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0,
30000);
do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0,
30000);
}
void bench_wuffs_gzip_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000);
do_bench_io_buffers(wuffs_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000);
}
// ---------------- Mimic Benches
@@ -225,13 +225,13 @@ void bench_wuffs_gzip_decode_100k() {
void bench_mimic_gzip_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0,
30000);
do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_midsummer_gt, 0, 0,
30000);
}
void bench_mimic_gzip_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000);
do_bench_io_buffers(mimic_gzip_decode, tc_dst, &gzip_pi_gt, 0, 0, 3000);
}
#endif // WUFFS_MIMIC
+27 -27
View File
@@ -124,7 +124,7 @@ void test_wuffs_adler32_golden() {
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, test_cases[i].filename)) {
return;
}
@@ -189,8 +189,8 @@ void test_wuffs_adler32_pi() {
// ---------------- Zlib Tests
const char* wuffs_zlib_decode(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_zlib__decoder dec;
@@ -199,12 +199,12 @@ const char* wuffs_zlib_decode(wuffs_base__buf1* dst,
uint64_t wlim = 0;
uint64_t rlim = 0;
while (true) {
wuffs_base__writer1 dst_writer = {.buf = dst};
wuffs_base__io_writer dst_writer = {.buf = dst};
if (wlimit) {
wlim = wlimit;
dst_writer.private_impl.limit.ptr_to_len = &wlim;
}
wuffs_base__reader1 src_reader = {.buf = src};
wuffs_base__io_reader src_reader = {.buf = src};
if (rlimit) {
rlim = rlimit;
src_reader.private_impl.limit.ptr_to_len = &rlim;
@@ -225,8 +225,8 @@ const char* wuffs_zlib_decode(wuffs_base__buf1* dst,
}
bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
if (!read_file(&src, zlib_midsummer_gt.src_filename)) {
return false;
@@ -246,9 +246,9 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
wuffs_zlib__decoder__initialize(&dec, WUFFS_VERSION, 0);
wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.wi = 0;
wuffs_base__writer1 got_writer = {.buf = &got};
wuffs_base__io_writer got_writer = {.buf = &got};
src.ri = 0;
wuffs_base__reader1 src_reader = {.buf = &src};
wuffs_base__io_reader src_reader = {.buf = &src};
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
// or isn't zero.
@@ -303,12 +303,12 @@ void test_wuffs_zlib_checksum_verify_good() {
void test_wuffs_zlib_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0);
do_test_io_buffers(wuffs_zlib_decode, &zlib_midsummer_gt, 0, 0);
}
void test_wuffs_zlib_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(wuffs_zlib_decode, &zlib_pi_gt, 0, 0);
do_test_io_buffers(wuffs_zlib_decode, &zlib_pi_gt, 0, 0);
}
// ---------------- Mimic Tests
@@ -317,12 +317,12 @@ void test_wuffs_zlib_decode_pi() {
void test_mimic_zlib_decode_midsummer() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0);
do_test_io_buffers(mimic_zlib_decode, &zlib_midsummer_gt, 0, 0);
}
void test_mimic_zlib_decode_pi() {
CHECK_FOCUS(__func__);
do_test_buf1_buf1(mimic_zlib_decode, &zlib_pi_gt, 0, 0);
do_test_io_buffers(mimic_zlib_decode, &zlib_pi_gt, 0, 0);
}
#endif // WUFFS_MIMIC
@@ -331,8 +331,8 @@ void test_mimic_zlib_decode_pi() {
uint32_t global_wuffs_zlib_unused_u32;
const char* wuffs_bench_adler32(wuffs_base__buf1* dst,
wuffs_base__buf1* src,
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.
@@ -349,26 +349,26 @@ const char* wuffs_bench_adler32(wuffs_base__buf1* dst,
void bench_wuffs_adler32_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0,
150000);
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_buf1_buf1(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000);
do_bench_io_buffers(wuffs_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000);
}
// ---------------- Zlib Benches
void bench_wuffs_zlib_decode_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0,
30000);
do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0,
30000);
}
void bench_wuffs_zlib_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
do_bench_io_buffers(wuffs_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
}
// ---------------- Mimic Benches
@@ -377,24 +377,24 @@ void bench_wuffs_zlib_decode_100k() {
void bench_mimic_adler32_10k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_bench_adler32, tc_src, &adler32_midsummer_gt, 0, 0,
150000);
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_buf1_buf1(mimic_bench_adler32, tc_src, &adler32_pi_gt, 0, 0, 15000);
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_buf1_buf1(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0,
30000);
do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_midsummer_gt, 0, 0,
30000);
}
void bench_mimic_zlib_decode_100k() {
CHECK_FOCUS(__func__);
do_bench_buf1_buf1(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
do_bench_io_buffers(mimic_zlib_decode, tc_dst, &zlib_pi_gt, 0, 0, 3000);
}
#endif // WUFFS_MIMIC
+42 -42
View File
@@ -264,10 +264,10 @@ int test_main(int argc, char** argv, proc* tests, proc* benches) {
return 0;
}
// WUFFS_BASE_HEADER_H is where wuffs_base__buf1 is defined.
// WUFFS_BASE_HEADER_H is where wuffs_base__io_buffer is defined.
#ifdef WUFFS_BASE_HEADER_H
bool read_file(wuffs_base__buf1* dst, const char* path) {
bool read_file(wuffs_base__io_buffer* dst, const char* path) {
if (!dst || !path) {
FAIL("read_file: NULL argument");
return false;
@@ -322,7 +322,7 @@ bool read_file(wuffs_base__buf1* dst, const char* path) {
return true;
}
char* hex_dump(char* msg, wuffs_base__buf1* buf, size_t i) {
char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
if (!msg || !buf) {
FAIL("hex_dump: NULL argument");
return NULL;
@@ -372,11 +372,11 @@ char* hex_dump(char* msg, wuffs_base__buf1* buf, size_t i) {
return msg;
}
bool buf1s_equal(const char* prefix,
wuffs_base__buf1* got,
wuffs_base__buf1* want) {
bool io_buffers_equal(const char* prefix,
wuffs_base__io_buffer* got,
wuffs_base__io_buffer* want) {
if (!got || !want) {
FAIL("%sbuf1s_equal: NULL argument", prefix);
FAIL("%sio_buffers_equal: NULL argument", prefix);
return false;
}
char* msg = fail_msg;
@@ -387,10 +387,10 @@ bool buf1s_equal(const char* prefix,
}
}
if (got->wi != want->wi) {
INCR_FAIL(msg, "%sbuf1s_equal: wi: got %zu, want %zu.\n", prefix, got->wi,
want->wi);
INCR_FAIL(msg, "%sio_buffers_equal: wi: got %zu, want %zu.\n", prefix,
got->wi, want->wi);
} else if (i < got->wi) {
INCR_FAIL(msg, "%sbuf1s_equal:\n", prefix);
INCR_FAIL(msg, "%sio_buffers_equal:\n", prefix);
} else {
return true;
}
@@ -411,16 +411,16 @@ typedef enum {
tc_src = 2,
} throughput_counter;
bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
wuffs_base__buf1*,
uint64_t,
uint64_t),
throughput_counter tc,
golden_test* gt,
uint64_t wlimit,
uint64_t rlimit,
uint64_t reps,
bool bench) {
bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
wuffs_base__io_buffer*,
uint64_t,
uint64_t),
throughput_counter tc,
golden_test* gt,
uint64_t wlimit,
uint64_t rlimit,
uint64_t reps,
bool bench) {
if (!codec_func) {
FAIL("NULL codec_func");
return false;
@@ -430,9 +430,9 @@ bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
return false;
}
wuffs_base__buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__buf1 want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer got = {.ptr = global_got_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer want = {.ptr = global_want_buffer, .len = BUFFER_SIZE};
if (!gt->src_filename) {
src.closed = true;
@@ -486,32 +486,32 @@ bool proc_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
} else if (!read_file(&want, gt->want_filename)) {
return false;
}
if (!buf1s_equal("", &got, &want)) {
if (!io_buffers_equal("", &got, &want)) {
return false;
}
return true;
}
bool do_bench_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
wuffs_base__buf1*,
uint64_t,
uint64_t),
throughput_counter tc,
golden_test* gt,
uint64_t wlimit,
uint64_t rlimit,
uint64_t reps) {
return proc_buf1_buf1(codec_func, tc, gt, wlimit, rlimit, reps, true);
bool do_bench_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
wuffs_base__io_buffer*,
uint64_t,
uint64_t),
throughput_counter tc,
golden_test* gt,
uint64_t wlimit,
uint64_t rlimit,
uint64_t reps) {
return proc_io_buffers(codec_func, tc, gt, wlimit, rlimit, reps, true);
}
bool do_test_buf1_buf1(const char* (*codec_func)(wuffs_base__buf1*,
wuffs_base__buf1*,
uint64_t,
uint64_t),
golden_test* gt,
uint64_t wlimit,
uint64_t rlimit) {
return proc_buf1_buf1(codec_func, tc_neither, gt, wlimit, rlimit, 1, false);
bool do_test_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
wuffs_base__io_buffer*,
uint64_t,
uint64_t),
golden_test* gt,
uint64_t wlimit,
uint64_t rlimit) {
return proc_io_buffers(codec_func, tc_neither, gt, wlimit, rlimit, 1, false);
}
#endif // WUFFS_BASE_HEADER_H