From 8827e222b1e48c0631da7168231cfd27d2da9625 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Fri, 27 Apr 2018 20:54:44 +1000 Subject: [PATCH] Add wuffs_base__io_buffer__{reader,writer} funcs --- cmd/wuffs-c/internal/cgen/base-header.h | 18 ++++++++++++++ cmd/wuffs-c/internal/cgen/data.go | 3 ++- example/gifplayer/gifplayer.c | 4 ++-- example/library/library.c | 4 ++-- example/zcat/zcat.c | 4 ++-- fuzz/c/fuzzlib/fuzzlib.cc | 2 +- fuzz/c/std/gif_fuzzer.cc | 2 +- fuzz/c/std/zlib_fuzzer.cc | 2 +- gen/c/std/adler32.c | 18 ++++++++++++++ gen/c/std/crc32.c | 18 ++++++++++++++ gen/c/std/deflate.c | 18 ++++++++++++++ gen/c/std/gif.c | 18 ++++++++++++++ gen/c/std/gzip.c | 18 ++++++++++++++ gen/c/std/zlib.c | 18 ++++++++++++++ gen/h/std/adler32.h | 18 ++++++++++++++ gen/h/std/crc32.h | 18 ++++++++++++++ gen/h/std/deflate.h | 18 ++++++++++++++ gen/h/std/gif.h | 18 ++++++++++++++ gen/h/std/gzip.h | 18 ++++++++++++++ gen/h/std/zlib.h | 18 ++++++++++++++ script/bench-c-deflate-fragmentation.c | 4 ++-- test/c/std/deflate.c | 12 +++++----- test/c/std/gif.c | 32 ++++++++++++------------- test/c/std/gzip.c | 8 +++---- test/c/std/zlib.c | 8 +++---- 25 files changed, 277 insertions(+), 42 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base-header.h b/cmd/wuffs-c/internal/cgen/base-header.h index 5bb272e5..580c5ee2 100644 --- a/cmd/wuffs-c/internal/cgen/base-header.h +++ b/cmd/wuffs-c/internal/cgen/base-header.h @@ -586,6 +586,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 0c5b4246..edf0b6af 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -50,7 +50,8 @@ const baseHeader = "" + "in_inclusive_x, s.min_inclusive_x);\n r.min_inclusive_y =\n wuffs_base__u32__min(r.min_inclusive_y, s.min_inclusive_y);\n r.max_exclusive_x =\n wuffs_base__u32__max(r.max_exclusive_x, s.max_exclusive_x);\n r.max_exclusive_y =\n wuffs_base__u32__max(r.max_exclusive_y, s.max_exclusive_y);\n return r;\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__width(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive_x, r.min_inclusive_x);\n}\n\nstatic inline uint32_t wuffs_base__rect_ie_u32__height(\n wuffs_base__rect_ie_u32 r) {\n return wuffs_base__u32__sat_sub(r.max_exclusive_y, r.min_inclusive_y);\n}\n\n" + "" + "// ---------------- I/O\n\n// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length), plus\n// additional indexes into that buffer, plus an opened / closed flag.\n//\n// A value with all fields NULL or zero is a valid, empty buffer.\ntypedef struct {\n uint8_t* ptr; // Pointer.\n size_t len; // Length.\n size_t wi; // Write index. Invariant: wi <= len.\n size_t ri; // Read index. Invariant: ri <= wi.\n bool closed; // No further writes are expected.\n} wuffs_base__io_buffer;\n\n// wuffs_base__io_limit provides a limited view of a 1-dimensional byte stream:\n// its first N bytes. That N can be greater than a buffer's current read or\n// write capacity. N decreases naturally over time as bytes are read from or\n// written to the stream.\n//\n// A value with all fields NULL or zero is a valid, unlimited view.\ntypedef struct wuffs_base__io_limit {\n uint64_t* ptr_to_len; // Pointer to N.\n struct wuffs_base__io_limit* next; // Linked list of limits.\n} wuffs_base__io_limit;\n\ntypedef" + - " struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_reader;\n\ntypedef struct {\n // TODO: move buf into private_impl? As it is, it looks like users can modify\n // the buf field to point to a different buffer, which can turn the limit and\n // mark fields into dangling pointers.\n wuffs_base__io_buffer* buf;\n // Do not access the private_impl's fields directly. There is no API/ABI\n // compatibility or safety guarantee if you do so.\n struct {\n wuffs_base__io_limit limit;\n uint8_t* mark;\n } private_impl;\n} wuffs_base__io_writer;\n\n" + + " 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\nstatic inline wuffs_base__io_reader wuffs_base__io_buffer__reader(\n" + + " wuffs_base__io_buffer* buf) {\n wuffs_base__io_reader ret = ((wuffs_base__io_reader){});\n if (buf) {\n ret.buf = buf;\n }\n return ret;\n}\n\nstatic inline wuffs_base__io_writer wuffs_base__io_buffer__writer(\n wuffs_base__io_buffer* buf) {\n wuffs_base__io_writer ret = ((wuffs_base__io_writer){});\n if (buf) {\n ret.buf = buf;\n }\n return ret;\n}\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 s" + diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 228353b6..832f165b 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -72,7 +72,7 @@ const char* play() { wuffs_base__io_buffer src = { .ptr = src_buffer, .len = src_len, .wi = src_len, .closed = true}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_base__image_config ic = {{0}}; wuffs_gif__status s = @@ -112,7 +112,7 @@ const char* play() { while (true) { wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = dst_len}; - wuffs_base__io_writer dst_writer = {.buf = &dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&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); diff --git a/example/library/library.c b/example/library/library.c index b18cc10c..e4fff9f5 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -51,8 +51,8 @@ static const char* decode() { 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__io_writer dst_writer = {.buf = &dst}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_deflate__decoder dec; wuffs_deflate__decoder__initialize(&dec, WUFFS_VERSION, 0); diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 115291bf..e305e4a3 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -69,11 +69,11 @@ static const char* decode() { .len = SRC_BUFFER_SIZE, .wi = n_src, .closed = n_src == 0}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); while (true) { wuffs_base__io_buffer dst = {.ptr = dst_buffer, .len = DST_BUFFER_SIZE}; - wuffs_base__io_writer dst_writer = {.buf = &dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); wuffs_gzip__status s = wuffs_gzip__decoder__decode(&dec, dst_writer, src_reader); diff --git a/fuzz/c/fuzzlib/fuzzlib.cc b/fuzz/c/fuzzlib/fuzzlib.cc index cff1c08f..96d20eeb 100644 --- a/fuzz/c/fuzzlib/fuzzlib.cc +++ b/fuzz/c/fuzzlib/fuzzlib.cc @@ -46,7 +46,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { .wi = size, .ri = 0, .closed = true}; - fuzz((wuffs_base__io_reader){.buf = &src}, hash); + fuzz(wuffs_base__io_buffer__reader(&src), hash); return 0; } diff --git a/fuzz/c/std/gif_fuzzer.cc b/fuzz/c/std/gif_fuzzer.cc index a2177da1..380bea35 100644 --- a/fuzz/c/std/gif_fuzzer.cc +++ b/fuzz/c/std/gif_fuzzer.cc @@ -65,7 +65,7 @@ void fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { } wuffs_base__io_buffer dst = {.ptr = (uint8_t*)(pixbuf), .len = pixbuf_size}; - wuffs_base__io_writer dst_writer = {.buf = &dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); while (true) { // TODO: handle the frame rect being larger than the image rect. The diff --git a/fuzz/c/std/zlib_fuzzer.cc b/fuzz/c/std/zlib_fuzzer.cc index 8b5f8878..85538c6a 100644 --- a/fuzz/c/std/zlib_fuzzer.cc +++ b/fuzz/c/std/zlib_fuzzer.cc @@ -53,7 +53,7 @@ void fuzz(wuffs_base__io_reader src_reader, uint32_t hash) { const size_t dstbuf_size = 65536; uint8_t dstbuf[dstbuf_size]; wuffs_base__io_buffer dst = {.ptr = dstbuf, .len = dstbuf_size}; - wuffs_base__io_writer dst_writer = {.buf = &dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); while (true) { dst.wi = 0; diff --git a/gen/c/std/adler32.c b/gen/c/std/adler32.c index 191573d1..c2ff14f5 100644 --- a/gen/c/std/adler32.c +++ b/gen/c/std/adler32.c @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/c/std/crc32.c b/gen/c/std/crc32.c index f554a0e2..9acad614 100644 --- a/gen/c/std/crc32.c +++ b/gen/c/std/crc32.c @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/c/std/deflate.c b/gen/c/std/deflate.c index 1fd11ca5..83f81f13 100644 --- a/gen/c/std/deflate.c +++ b/gen/c/std/deflate.c @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 5a20ebb8..6b4936c8 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/c/std/gzip.c b/gen/c/std/gzip.c index 2383f8df..f616b4fe 100644 --- a/gen/c/std/gzip.c +++ b/gen/c/std/gzip.c @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/c/std/zlib.c b/gen/c/std/zlib.c index 6b842d98..24f8517a 100644 --- a/gen/c/std/zlib.c +++ b/gen/c/std/zlib.c @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/h/std/adler32.h b/gen/h/std/adler32.h index 06ee5348..9f53c0ab 100644 --- a/gen/h/std/adler32.h +++ b/gen/h/std/adler32.h @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/h/std/crc32.h b/gen/h/std/crc32.h index 39701c5f..c1e63546 100644 --- a/gen/h/std/crc32.h +++ b/gen/h/std/crc32.h @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/h/std/deflate.h b/gen/h/std/deflate.h index 820c0245..ff922343 100644 --- a/gen/h/std/deflate.h +++ b/gen/h/std/deflate.h @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/h/std/gif.h b/gen/h/std/gif.h index 795a47d3..d0cc7940 100644 --- a/gen/h/std/gif.h +++ b/gen/h/std/gif.h @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/h/std/gzip.h b/gen/h/std/gzip.h index 0907af26..bb734182 100644 --- a/gen/h/std/gzip.h +++ b/gen/h/std/gzip.h @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/gen/h/std/zlib.h b/gen/h/std/zlib.h index d143453a..54daecbd 100644 --- a/gen/h/std/zlib.h +++ b/gen/h/std/zlib.h @@ -589,6 +589,24 @@ typedef struct { } private_impl; } wuffs_base__io_writer; +static inline wuffs_base__io_reader wuffs_base__io_buffer__reader( + wuffs_base__io_buffer* buf) { + wuffs_base__io_reader ret = ((wuffs_base__io_reader){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + +static inline wuffs_base__io_writer wuffs_base__io_buffer__writer( + wuffs_base__io_buffer* buf) { + wuffs_base__io_writer ret = ((wuffs_base__io_writer){}); + if (buf) { + ret.buf = buf; + } + return ret; +} + // ---------------- Images // wuffs_base__pixel_format encodes the format of the bytes that constitute an diff --git a/script/bench-c-deflate-fragmentation.c b/script/bench-c-deflate-fragmentation.c index adb40ce5..b6dde288 100644 --- a/script/bench-c-deflate-fragmentation.c +++ b/script/bench-c-deflate-fragmentation.c @@ -218,8 +218,8 @@ const char* decode_once(bool frag_dst, bool frag_idat) { .len = SRC_BUFFER_SIZE, .wi = idat_splits[num_idat_chunks], .closed = true}; - wuffs_base__io_writer dst_writer = {.buf = &dst}; - wuffs_base__io_reader idat_reader = {.buf = &idat}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); + wuffs_base__io_reader idat_reader = wuffs_base__io_buffer__reader(&idat); uint32_t i = 0; // Number of dst fragments processed, if frag_dst. if (frag_dst) { diff --git a/test/c/std/deflate.c b/test/c/std/deflate.c index 2197b694..889399b5 100644 --- a/test/c/std/deflate.c +++ b/test/c/std/deflate.c @@ -116,12 +116,12 @@ const char* wuffs_deflate_decode(wuffs_base__io_buffer* dst, uint64_t wlim = 0; uint64_t rlim = 0; while (true) { - wuffs_base__io_writer dst_writer = {.buf = dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); if (wlimit) { wlim = wlimit; dst_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__io_reader src_reader = {.buf = src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -209,8 +209,8 @@ void test_wuffs_deflate_decode_split_src() { } wuffs_deflate__decoder dec; - wuffs_base__io_writer dst_writer = {.buf = &got}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&got); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); int i; for (i = 1; i < 32; i++) { @@ -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__io_writer dst_writer = {.buf = got}; - wuffs_base__io_reader src_reader = {.buf = src}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(got); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); dec->private_impl.f_history_index = starting_history_index; diff --git a/test/c/std/gif.c b/test/c/std/gif.c index 5185096c..063acef0 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -212,12 +212,12 @@ bool do_test_wuffs_lzw_decode(const char* src_filename, uint64_t rlim = 0; while (true) { num_iters++; - wuffs_base__io_writer got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); if (wlimit) { wlim = wlimit; got_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -310,8 +310,8 @@ void test_wuffs_lzw_decode_pi() { bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t reps) { 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}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); if (!read_file(&src, filename)) { return false; @@ -363,8 +363,8 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst, wuffs_gif__decoder dec; wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); wuffs_base__image_config ic = {{0}}; - wuffs_base__io_writer dst_writer = {.buf = dst}; - wuffs_base__io_reader src_reader = {.buf = src}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); wuffs_gif__status s = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); if (s) { @@ -394,7 +394,7 @@ bool do_test_wuffs_gif_decode(const char* filename, { wuffs_base__image_config ic = {{0}}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); if (status != WUFFS_GIF__STATUS_OK) { @@ -433,12 +433,12 @@ bool do_test_wuffs_gif_decode(const char* filename, uint64_t rlim = 0; while (true) { num_iters++; - wuffs_base__io_writer got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); if (wlimit) { wlim = wlimit; got_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -516,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__io_writer got_writer = {.buf = &got}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_gif__status status = wuffs_gif__decoder__decode_frame(&dec, got_writer, src_reader); if (status != WUFFS_GIF__SUSPENSION_END_OF_DATA) { @@ -548,8 +548,8 @@ void test_wuffs_gif_call_sequence() { wuffs_gif__decoder dec; wuffs_gif__decoder__initialize(&dec, WUFFS_VERSION, 0); - wuffs_base__io_writer got_writer = {.buf = &got}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_gif__status status = wuffs_gif__decoder__decode_frame(&dec, got_writer, src_reader); @@ -576,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__io_writer got_writer = {.buf = &got}; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); @@ -670,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__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); wuffs_gif__status status = wuffs_gif__decoder__decode_config(&dec, &ic, src_reader); diff --git a/test/c/std/gzip.c b/test/c/std/gzip.c index 6129fc72..931771b7 100644 --- a/test/c/std/gzip.c +++ b/test/c/std/gzip.c @@ -72,12 +72,12 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst, uint64_t wlim = 0; uint64_t rlim = 0; while (true) { - wuffs_base__io_writer dst_writer = {.buf = dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); if (wlimit) { wlim = wlimit; dst_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__io_reader src_reader = {.buf = src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -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__io_writer got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); src.ri = 0; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); // Decode the src data in 1 or 2 chunks, depending on whether end_limit is // or isn't zero. diff --git a/test/c/std/zlib.c b/test/c/std/zlib.c index 8436c433..064ba8a7 100644 --- a/test/c/std/zlib.c +++ b/test/c/std/zlib.c @@ -87,12 +87,12 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst, uint64_t wlim = 0; uint64_t rlim = 0; while (true) { - wuffs_base__io_writer dst_writer = {.buf = dst}; + wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(dst); if (wlimit) { wlim = wlimit; dst_writer.private_impl.limit.ptr_to_len = &wlim; } - wuffs_base__io_reader src_reader = {.buf = src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src); if (rlimit) { rlim = rlimit; src_reader.private_impl.limit.ptr_to_len = &rlim; @@ -134,9 +134,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__io_writer got_writer = {.buf = &got}; + wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got); src.ri = 0; - wuffs_base__io_reader src_reader = {.buf = &src}; + wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src); // Decode the src data in 1 or 2 chunks, depending on whether end_limit is // or isn't zero.