Split an io_buffer's fields into data and meta

This commit is contained in:
Nigel Tao committed 2018-09-15 08:45:50 +10:00
1 parent 2e804c8f20
commit 6fed251b40
21 files changed
+706 -526

No files matched your search

+19 -19
View File
@@ -42,14 +42,14 @@ const char* mimic_deflate_zlib_decode(wuffs_base__io_buffer* dst,
if (!deflate_instead_of_zlib) {
flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
}
size_t n =
tinfl_decompress_mem_to_mem(dst->ptr + dst->wi, dst->len - dst->wi,
src->ptr + src->ri, src->wi - src->ri, flags);
size_t n = tinfl_decompress_mem_to_mem(
dst->data.ptr + dst->meta.wi, dst->data.len - dst->meta.wi,
src->data.ptr + src->meta.ri, src->meta.wi - src->meta.ri, flags);
if (n == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) {
return "TINFL_DECOMPRESS_MEM_TO_MEM_FAILED";
}
dst->wi += n;
src->ri = src->wi;
dst->meta.wi += n;
src->meta.ri = src->meta.wi;
return NULL;
}
@@ -84,13 +84,13 @@ const char* mimic_bench_adler32(wuffs_base__io_buffer* dst,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
uint8_t* ptr = src->ptr + src->ri;
size_t len = src->wi - src->ri;
uint8_t* ptr = src->data.ptr + src->meta.ri;
size_t len = src->meta.wi - src->meta.ri;
if (len > 0x7FFFFFFF) {
return "src length is too large";
}
global_mimiclib_deflate_unused_u32 = adler32(0L, ptr, len);
src->ri = src->wi;
src->meta.ri = src->meta.wi;
return NULL;
}
@@ -99,13 +99,13 @@ const char* mimic_bench_crc32_ieee(wuffs_base__io_buffer* dst,
uint64_t wlimit,
uint64_t rlimit) {
// TODO: don't ignore wlimit and rlimit.
uint8_t* ptr = src->ptr + src->ri;
size_t len = src->wi - src->ri;
uint8_t* ptr = src->data.ptr + src->meta.ri;
size_t len = src->meta.wi - src->meta.ri;
if (len > 0x7FFFFFFF) {
return "src length is too large";
}
global_mimiclib_deflate_unused_u32 = crc32(0L, ptr, len);
src->ri = src->wi;
src->meta.ri = src->meta.wi;
return NULL;
}
@@ -147,10 +147,10 @@ const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
goto cleanup0;
}
z.avail_in = src->wi - src->ri;
z.next_in = src->ptr + src->ri;
z.avail_out = dst->len - dst->wi;
z.next_out = dst->ptr + dst->wi;
z.avail_in = src->meta.wi - src->meta.ri;
z.next_in = src->data.ptr + src->meta.ri;
z.avail_out = dst->data.len - dst->meta.wi;
z.next_out = dst->data.ptr + dst->meta.wi;
int i_err = inflate(&z, Z_NO_FLUSH);
if (i_err != Z_STREAM_END) {
@@ -158,21 +158,21 @@ const char* mimic_deflate_gzip_zlib_decode(wuffs_base__io_buffer* dst,
goto cleanup1;
}
size_t readable = src->wi - src->ri;
size_t readable = src->meta.wi - src->meta.ri;
size_t r_remaining = z.avail_in;
if (readable < r_remaining) {
ret = "inconsistent avail_in";
goto cleanup1;
}
src->ri += readable - r_remaining;
src->meta.ri += readable - r_remaining;
size_t writable = dst->len - dst->wi;
size_t writable = dst->data.len - dst->meta.wi;
size_t w_remaining = z.avail_out;
if (writable < w_remaining) {
ret = "inconsistent avail_out";
goto cleanup1;
}
dst->wi += writable - w_remaining;
dst->meta.wi += writable - w_remaining;
cleanup1:;
int ie_err = inflateEnd(&z);
+6 -6
View File
@@ -20,12 +20,12 @@ int mimic_gif_read_func(GifFileType* f, GifByteType* ptr, int len) {
return 0;
}
size_t n = (size_t)(len);
size_t num_src = src->wi - src->ri;
size_t num_src = src->meta.wi - src->meta.ri;
if (n > num_src) {
n = num_src;
}
memmove(ptr, src->ptr + src->ri, n);
src->ri += n;
memmove(ptr, src->data.ptr + src->meta.ri, n);
src->meta.ri += n;
return n;
}
@@ -70,13 +70,13 @@ const char* mimic_gif_decode(wuffs_base__io_buffer* dst,
struct SavedImage* si = &f->SavedImages[i];
size_t num_src =
(size_t)(si->ImageDesc.Width) * (size_t)(si->ImageDesc.Height);
size_t num_dst = dst->len - dst->wi;
size_t num_dst = dst->data.len - dst->meta.wi;
if (num_dst < num_src) {
ret = "GIF image's pixel data won't fit in the dst buffer";
goto cleanup1;
}
memmove(dst->ptr + dst->wi, si->RasterBits, num_src);
dst->wi += num_src;
memmove(dst->data.ptr + dst->meta.wi, si->RasterBits, num_src);
dst->meta.wi += num_src;
}
cleanup1:;
+13 -12
View File
@@ -117,8 +117,9 @@ void test_wuffs_adler32_golden() {
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, test_cases[i].filename)) {
return;
}
@@ -138,8 +139,8 @@ void test_wuffs_adler32_golden() {
size_t num_bytes = 0;
do {
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
.ptr = src.ptr + num_bytes,
.len = src.wi - num_bytes,
.ptr = src.data.ptr + num_bytes,
.len = src.meta.wi - num_bytes,
});
size_t limit = 101 + 103 * num_fragments;
if ((j > 0) && (data.len > limit)) {
@@ -148,7 +149,7 @@ void test_wuffs_adler32_golden() {
got = wuffs_adler32__hasher__update(&checksum, data);
num_fragments++;
num_bytes += data.len;
} while (num_bytes < src.wi);
} while (num_bytes < src.meta.wi);
if (got != test_cases[i].want) {
FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32
@@ -217,7 +218,7 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
uint64_t len = src->wi - src->ri;
uint64_t len = src->meta.wi - src->meta.ri;
if (rlimit) {
len = wuffs_base__u64__min(len, rlimit);
}
@@ -227,12 +228,12 @@ const char* wuffs_bench_adler32(wuffs_base__io_buffer* dst,
if (z) {
return z;
}
global_wuffs_adler32_unused_u32 =
wuffs_adler32__hasher__update(&checksum, ((wuffs_base__slice_u8){
.ptr = src->ptr + src->ri,
.len = len,
}));
src->ri += len;
global_wuffs_adler32_unused_u32 = wuffs_adler32__hasher__update(
&checksum, ((wuffs_base__slice_u8){
.ptr = src->data.ptr + src->meta.ri,
.len = len,
}));
src->meta.ri += len;
return NULL;
}
+13 -12
View File
@@ -117,8 +117,9 @@ void test_wuffs_crc32_ieee_golden() {
int i;
for (i = 0; i < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) {
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, test_cases[i].filename)) {
return;
}
@@ -138,8 +139,8 @@ void test_wuffs_crc32_ieee_golden() {
size_t num_bytes = 0;
do {
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
.ptr = src.ptr + num_bytes,
.len = src.wi - num_bytes,
.ptr = src.data.ptr + num_bytes,
.len = src.meta.wi - num_bytes,
});
size_t limit = 101 + 103 * num_fragments;
if ((j > 0) && (data.len > limit)) {
@@ -148,7 +149,7 @@ void test_wuffs_crc32_ieee_golden() {
got = wuffs_crc32__ieee_hasher__update(&checksum, data);
num_fragments++;
num_bytes += data.len;
} while (num_bytes < src.wi);
} while (num_bytes < src.meta.wi);
if (got != test_cases[i].want) {
FAIL("i=%d, j=%d, filename=\"%s\": got 0x%08" PRIX32
@@ -217,7 +218,7 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
wuffs_base__io_buffer* src,
uint64_t wlimit,
uint64_t rlimit) {
uint64_t len = src->wi - src->ri;
uint64_t len = src->meta.wi - src->meta.ri;
if (rlimit) {
len = wuffs_base__u64__min(len, rlimit);
}
@@ -227,12 +228,12 @@ const char* wuffs_bench_crc32_ieee(wuffs_base__io_buffer* dst,
if (z) {
return z;
}
global_wuffs_crc32_unused_u32 =
wuffs_crc32__ieee_hasher__update(&checksum, ((wuffs_base__slice_u8){
.ptr = src->ptr + src->ri,
.len = len,
}));
src->ri += len;
global_wuffs_crc32_unused_u32 = wuffs_crc32__ieee_hasher__update(
&checksum, ((wuffs_base__slice_u8){
.ptr = src->data.ptr + src->meta.ri,
.len = len,
}));
src->meta.ri += len;
return NULL;
}
+47 -35
View File
@@ -214,12 +214,15 @@ void test_wuffs_deflate_decode_romeo_fixed() {
void test_wuffs_deflate_decode_split_src() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
golden_test* gt = &deflate_256_bytes_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -239,7 +242,7 @@ void test_wuffs_deflate_decode_split_src() {
FAIL("i=%d: split was not an interior split", i);
return;
}
got.wi = 0;
got.meta.wi = 0;
wuffs_deflate__decoder dec = ((wuffs_deflate__decoder){});
wuffs_base__status z = wuffs_deflate__decoder__check_wuffs_version(
@@ -249,15 +252,15 @@ void test_wuffs_deflate_decode_split_src() {
return;
}
src.closed = false;
src.ri = gt->src_offset0;
src.wi = split;
src.meta.closed = false;
src.meta.ri = gt->src_offset0;
src.meta.wi = split;
wuffs_base__status z0 =
wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
src.closed = true;
src.ri = split;
src.wi = gt->src_offset1;
src.meta.closed = true;
src.meta.ri = split;
src.meta.wi = gt->src_offset1;
wuffs_base__status z1 =
wuffs_deflate__decoder__decode(&dec, dst_writer, src_reader);
@@ -288,10 +291,10 @@ bool do_test_wuffs_deflate_history(int i,
uint32_t starting_history_index,
uint64_t limit,
const char* want_z) {
src->ri = gt->src_offset0;
src->wi = gt->src_offset1;
got->ri = 0;
got->wi = 0;
src->meta.ri = gt->src_offset0;
src->meta.wi = gt->src_offset1;
got->meta.ri = 0;
got->meta.wi = 0;
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(got);
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(src);
@@ -314,12 +317,15 @@ bool do_test_wuffs_deflate_history(int i,
void test_wuffs_deflate_history_full() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
golden_test* gt = &deflate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
@@ -341,7 +347,7 @@ void test_wuffs_deflate_history_full() {
}
if (!do_test_wuffs_deflate_history(
i, gt, &src, &got, &dec, 0, want.wi + i,
i, gt, &src, &got, &dec, 0, want.meta.wi + i,
i >= 0 ? NULL : wuffs_base__suspension__short_write)) {
return;
}
@@ -357,19 +363,23 @@ void test_wuffs_deflate_history_full() {
}
wuffs_base__io_buffer history_got = ((wuffs_base__io_buffer){
.ptr = dec.private_impl.f_history,
.len = full_history_size,
.wi = full_history_size,
.data = ((wuffs_base__slice_u8){
.ptr = dec.private_impl.f_history,
.len = full_history_size,
}),
});
if (want.wi < full_history_size - i) {
history_got.meta.wi = full_history_size;
if (want.meta.wi < full_history_size - i) {
FAIL("i=%d: want file is too short", i);
return;
}
wuffs_base__io_buffer history_want = ((wuffs_base__io_buffer){
.ptr = global_want_buffer + want.wi - (full_history_size - i),
.len = full_history_size,
.wi = full_history_size,
.data = ((wuffs_base__slice_u8){
.ptr = global_want_array + want.meta.wi - (full_history_size - i),
.len = full_history_size,
}),
});
history_want.meta.wi = full_history_size;
if (!io_buffers_equal("", &history_got, &history_want)) {
return;
}
@@ -379,10 +389,12 @@ void test_wuffs_deflate_history_full() {
void test_wuffs_deflate_history_partial() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
golden_test* gt = &deflate_pi_gt;
if (!read_file(&src, gt->src_filename)) {
+99 -99
View File
@@ -212,12 +212,8 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg,
((wuffs_base__slice_u8){
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
return z;
}
@@ -227,7 +223,7 @@ const char* wuffs_gif_decode(wuffs_base__io_buffer* dst,
return "work buffer size is too large";
}
wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){
.ptr = global_work_buffer,
.ptr = global_work_array,
.len = workbuf_len,
});
@@ -258,10 +254,12 @@ bool do_test_wuffs_gif_decode(const char* filename,
const char* palette_filename,
const char* indexes_filename,
uint64_t rlimit) {
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, filename)) {
return false;
@@ -319,12 +317,8 @@ bool do_test_wuffs_gif_decode(const char* filename,
FAIL("first_frame_is_opaque: got false, want true");
return false;
}
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg,
((wuffs_base__slice_u8){
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return false;
@@ -332,7 +326,7 @@ bool do_test_wuffs_gif_decode(const char* filename,
}
wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){
.ptr = global_work_buffer,
.ptr = global_work_array,
.len = 160,
});
@@ -343,7 +337,7 @@ bool do_test_wuffs_gif_decode(const char* filename,
if (rlimit) {
set_reader_limit(&src_reader, rlimit);
}
size_t old_ri = src.ri;
size_t old_ri = src.meta.ri;
wuffs_base__status z =
wuffs_gif__decoder__decode_frame_config(&dec, &fc, src_reader);
@@ -357,11 +351,11 @@ bool do_test_wuffs_gif_decode(const char* filename,
return false;
}
if (src.ri < old_ri) {
FAIL("read index src.ri went backwards");
if (src.meta.ri < old_ri) {
FAIL("read index src.meta.ri went backwards");
return false;
}
if (src.ri == old_ri) {
if (src.meta.ri == old_ri) {
FAIL("no progress was made");
return false;
}
@@ -373,7 +367,7 @@ bool do_test_wuffs_gif_decode(const char* filename,
if (rlimit) {
set_reader_limit(&src_reader, rlimit);
}
size_t old_ri = src.ri;
size_t old_ri = src.meta.ri;
wuffs_base__status z =
wuffs_gif__decoder__decode_frame(&dec, &pb, src_reader, workbuf, NULL);
@@ -387,11 +381,11 @@ bool do_test_wuffs_gif_decode(const char* filename,
return false;
}
if (src.ri < old_ri) {
FAIL("read index src.ri went backwards");
if (src.meta.ri < old_ri) {
FAIL("read index src.meta.ri went backwards");
return false;
}
if (src.ri == old_ri) {
if (src.meta.ri == old_ri) {
FAIL("no progress was made");
return false;
}
@@ -418,12 +412,17 @@ bool do_test_wuffs_gif_decode(const char* filename,
}
}
wuffs_base__slice_u8 pal_got_slice = wuffs_base__pixel_buffer__palette(&pb);
wuffs_base__io_buffer pal_got = {.ptr = pal_got_slice.ptr,
.len = pal_got_slice.len,
.wi = pal_got_slice.len};
wuffs_base__io_buffer pal_got = ((wuffs_base__io_buffer){
.data = wuffs_base__pixel_buffer__palette(&pb),
});
pal_got.meta.wi = pal_got.data.len;
uint8_t pal_want_array[1024];
wuffs_base__io_buffer pal_want = {.ptr = pal_want_array, .len = 1024};
wuffs_base__io_buffer pal_want = ((wuffs_base__io_buffer){
.data = ((wuffs_base__slice_u8){
.ptr = pal_want_array,
.len = 1024,
}),
});
if (!read_file(&pal_want, palette_filename)) {
return false;
}
@@ -431,8 +430,9 @@ bool do_test_wuffs_gif_decode(const char* filename,
return false;
}
wuffs_base__io_buffer ind_want = {.ptr = global_want_buffer,
.len = BUFFER_SIZE};
wuffs_base__io_buffer ind_want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
if (!read_file(&ind_want, indexes_filename)) {
return false;
}
@@ -441,7 +441,7 @@ bool do_test_wuffs_gif_decode(const char* filename,
}
{
if (src.ri == src.wi) {
if (src.meta.ri == src.meta.wi) {
FAIL("decode_frame returned \"ok\" but src was exhausted");
return false;
}
@@ -453,7 +453,7 @@ bool do_test_wuffs_gif_decode(const char* filename,
wuffs_base__warning__end_of_data);
return false;
}
if (src.ri != src.wi) {
if (src.meta.ri != src.meta.wi) {
FAIL("decode_frame returned \"end of data\" but src was not exhausted");
return false;
}
@@ -465,8 +465,9 @@ bool do_test_wuffs_gif_decode(const char* filename,
void test_wuffs_gif_call_sequence() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, "../../data/bricks-dither.gif")) {
return;
@@ -501,7 +502,9 @@ bool do_test_wuffs_gif_decode_animated(
uint32_t want_num_loops,
uint32_t want_num_frames,
wuffs_base__rect_ie_u32* want_frame_config_bounds) {
wuffs_base__io_buffer src = {.ptr = global_src_buffer, .len = BUFFER_SIZE};
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, filename)) {
return false;
@@ -529,7 +532,7 @@ bool do_test_wuffs_gif_decode_animated(
return "work buffer size is too large";
}
wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){
.ptr = global_work_buffer,
.ptr = global_work_array,
.len = workbuf_len,
});
@@ -540,12 +543,8 @@ bool do_test_wuffs_gif_decode_animated(
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg,
((wuffs_base__slice_u8){
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return false;
@@ -634,8 +633,9 @@ void test_wuffs_gif_decode_animated_small() {
void test_wuffs_gif_decode_frame_out_of_bounds() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, "../../data/artificial/gif-frame-out-of-bounds.gif")) {
return;
}
@@ -675,12 +675,8 @@ void test_wuffs_gif_decode_frame_out_of_bounds() {
}
wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){});
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg,
((wuffs_base__slice_u8){
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return;
@@ -692,7 +688,7 @@ void test_wuffs_gif_decode_frame_out_of_bounds() {
return;
}
wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){
.ptr = global_work_buffer,
.ptr = global_work_array,
.len = workbuf_len,
});
@@ -813,8 +809,9 @@ void test_wuffs_gif_decode_input_is_a_gif_many_small_reads() {
void test_wuffs_gif_decode_input_is_a_png() {
CHECK_FOCUS(__func__);
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, "../../data/bricks-dither.png")) {
return;
@@ -839,8 +836,9 @@ void test_wuffs_gif_decode_input_is_a_png() {
}
bool do_test_wuffs_gif_num_decoded(bool frame_config) {
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, "../../data/animated-red-blue.gif")) {
return false;
@@ -864,12 +862,8 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
return false;
}
z = wuffs_base__pixel_buffer__set_from_slice(
&pb, &ic.pixcfg,
((wuffs_base__slice_u8){
.ptr = global_pixel_buffer,
.len = WUFFS_TESTLIB_ARRAY_SIZE(global_pixel_buffer),
}));
z = wuffs_base__pixel_buffer__set_from_slice(&pb, &ic.pixcfg,
global_pixel_slice);
if (z) {
FAIL("set_from_slice: \"%s\"", z);
return false;
@@ -877,7 +871,7 @@ bool do_test_wuffs_gif_num_decoded(bool frame_config) {
}
wuffs_base__slice_u8 workbuf = ((wuffs_base__slice_u8){
.ptr = global_work_buffer,
.ptr = global_work_array,
.len = 64,
});
@@ -935,8 +929,9 @@ void test_wuffs_gif_num_decoded_frames() {
}
bool do_test_wuffs_gif_io_position(bool chunked) {
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, "../../data/animated-red-blue.gif")) {
return false;
}
@@ -952,14 +947,14 @@ bool do_test_wuffs_gif_io_position(bool chunked) {
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
if (chunked) {
if (src.wi < 50) {
if (src.meta.wi < 50) {
FAIL("src is too short");
return false;
}
size_t saved_wi = src.wi;
bool saved_closed = src.closed;
src.wi = 30;
src.closed = false;
size_t saved_wi = src.meta.wi;
bool saved_closed = src.meta.closed;
src.meta.wi = 30;
src.meta.closed = false;
z = wuffs_gif__decoder__decode_image_config(&dec, NULL, src_reader);
if (z != wuffs_base__suspension__short_read) {
@@ -967,16 +962,16 @@ bool do_test_wuffs_gif_io_position(bool chunked) {
return false;
}
src.wi = saved_wi;
src.closed = saved_closed;
src.meta.wi = saved_wi;
src.meta.closed = saved_closed;
if (src.pos != 0) {
FAIL("src.pos: got %" PRIu64 ", want zero", src.pos);
if (src.meta.pos != 0) {
FAIL("src.meta.pos: got %" PRIu64 ", want zero", src.meta.pos);
return false;
}
wuffs_base__io_buffer__compact(&src);
if (src.pos == 0) {
FAIL("src.pos: got %" PRIu64 ", want non-zero", src.pos);
if (src.meta.pos == 0) {
FAIL("src.meta.pos: got %" PRIu64 ", want non-zero", src.meta.pos);
return false;
}
}
@@ -1026,16 +1021,16 @@ bool do_test_wuffs_gif_io_position(bool chunked) {
// Look for the 0x21 byte that's a GIF's Extension Introducer. Not every
// GIF's frame_config's I/O position will point to 0x21, as an 0x2C Image
// Separator is also valid. But for animated-red-blue.gif, it'll be 0x21.
if (pos_got < src.pos) {
if (pos_got < src.meta.pos) {
FAIL("io_position #%d: got %" PRIu64 ", was too small", i, pos_got);
return false;
}
uint64_t src_ptr_offset = pos_got - src.pos;
if (src_ptr_offset >= src.wi) {
uint64_t src_ptr_offset = pos_got - src.meta.pos;
if (src_ptr_offset >= src.meta.wi) {
FAIL("io_position #%d: got %" PRIu64 ", was too large", i, pos_got);
return false;
}
uint8_t x = src.ptr[src_ptr_offset];
uint8_t x = src.data.ptr[src_ptr_offset];
if (x != 0x21) {
FAIL("Image Descriptor byte #%d: got 0x%02X, want 0x2C", i, (int)x);
return false;
@@ -1056,7 +1051,7 @@ bool do_test_wuffs_gif_io_position(bool chunked) {
}
for (i = 0; i < 4; i++) {
src.ri = pos_wants[i];
src.meta.ri = pos_wants[i];
z = wuffs_gif__decoder__restart_frame(
&dec, i, wuffs_base__frame_config__io_position(&fcs[i]));
@@ -1116,24 +1111,27 @@ void test_wuffs_gif_io_position_two_chunks() {
#ifdef WUFFS_MIMIC
bool do_test_mimic_gif_decode(const char* filename) {
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, filename)) {
return false;
}
src.ri = 0;
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
src.meta.ri = 0;
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
const char* got_msg = wuffs_gif_decode(&got, &src);
if (got_msg) {
FAIL("%s", got_msg);
return false;
}
src.ri = 0;
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
src.meta.ri = 0;
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
const char* want_msg = mimic_gif_decode(&want, &src);
if (want_msg) {
FAIL("%s", want_msg);
@@ -1218,10 +1216,12 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*,
wuffs_base__io_buffer*),
const char* filename,
uint64_t iters_unscaled) {
wuffs_base__io_buffer dst =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, filename)) {
return false;
@@ -1232,14 +1232,14 @@ bool do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*,
uint64_t i;
uint64_t iters = iters_unscaled * iterscale;
for (i = 0; i < iters; i++) {
dst.wi = 0;
src.ri = 0;
const char* error_msg = decode_func(&dst, &src);
got.meta.wi = 0;
src.meta.ri = 0;
const char* error_msg = decode_func(&got, &src);
if (error_msg) {
FAIL("%s", error_msg);
return false;
}
n_bytes += dst.wi;
n_bytes += got.meta.wi;
}
bench_finish(iters, n_bytes);
return true;
+12 -10
View File
@@ -114,22 +114,24 @@ const char* wuffs_gzip_decode(wuffs_base__io_buffer* dst,
}
bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, gzip_midsummer_gt.src_filename)) {
return false;
}
// Flip a bit in the gzip checksum, which is in the last 8 bytes of the file.
if (src.wi < 8) {
if (src.meta.wi < 8) {
FAIL("source file was too short");
return false;
}
if (bad_checksum) {
src.ptr[src.wi - 1 - (bad_checksum & 7)] ^= 1;
src.data.ptr[src.meta.wi - 1 - (bad_checksum & 7)] ^= 1;
}
int end_limit;
@@ -142,9 +144,9 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
return false;
}
wuffs_gzip__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.wi = 0;
got.meta.wi = 0;
wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
src.ri = 0;
src.meta.ri = 0;
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
// or isn't zero.
@@ -156,11 +158,11 @@ bool do_test_wuffs_gzip_checksum(bool ignore_checksum, uint32_t bad_checksum) {
if (end_limit == 0) {
continue;
}
if (src.wi < end_limit) {
if (src.meta.wi < end_limit) {
FAIL("end_limit=%d: not enough source data", end_limit);
return false;
}
set_reader_limit(&src_reader, src.wi - (uint64_t)(end_limit));
set_reader_limit(&src_reader, src.meta.wi - (uint64_t)(end_limit));
want_z = wuffs_base__suspension__short_read;
} else {
want_z = (bad_checksum && !ignore_checksum)
+37 -32
View File
@@ -70,33 +70,36 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
uint64_t want_size,
uint64_t wlimit,
uint64_t rlimit) {
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, src_filename)) {
return false;
}
if (src.wi != src_size) {
FAIL("src size: got %d, want %d", (int)(src.wi), (int)(src_size));
if (src.meta.wi != src_size) {
FAIL("src size: got %d, want %d", (int)(src.meta.wi), (int)(src_size));
return false;
}
// The first byte in that file, the LZW literal width, should be 0x08.
uint8_t literal_width = src.ptr[0];
uint8_t literal_width = src.data.ptr[0];
if (literal_width != 0x08) {
FAIL("LZW literal width: got %d, want %d", (int)(src.ptr[0]), 0x08);
FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), 0x08);
return false;
}
src.ri++;
src.meta.ri++;
if (!read_file(&want, want_filename)) {
return false;
}
if (want.wi != want_size) {
FAIL("want size: got %d, want %d", (int)(want.wi), (int)(want_size));
if (want.meta.wi != want_size) {
FAIL("want size: got %d, want %d", (int)(want.meta.wi), (int)(want_size));
return false;
}
@@ -119,12 +122,12 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
if (rlimit) {
set_reader_limit(&src_reader, rlimit);
}
size_t old_wi = got.wi;
size_t old_ri = src.ri;
size_t old_wi = got.meta.wi;
size_t old_ri = src.meta.ri;
z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (!z) {
if (src.ri != src.wi) {
if (src.meta.ri != src.meta.wi) {
FAIL("decode returned \"ok\" but src was not exhausted");
return false;
}
@@ -138,15 +141,15 @@ bool do_test_wuffs_lzw_decode(const char* src_filename,
return false;
}
if (got.wi < old_wi) {
if (got.meta.wi < old_wi) {
FAIL("write index got.wi went backwards");
return false;
}
if (src.ri < old_ri) {
if (src.meta.ri < old_ri) {
FAIL("read index src.ri went backwards");
return false;
}
if ((got.wi == old_wi) && (src.ri == old_ri)) {
if ((got.meta.wi == old_wi) && (src.meta.ri == old_ri)) {
FAIL("no progress was made");
return false;
}
@@ -200,23 +203,25 @@ void test_wuffs_lzw_decode_pi() {
// ---------------- LZW Benches
bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
wuffs_base__io_buffer dst =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_writer dst_writer = wuffs_base__io_buffer__writer(&dst);
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
wuffs_base__io_reader src_reader = wuffs_base__io_buffer__reader(&src);
if (!read_file(&src, filename)) {
return false;
}
if (src.wi <= 0) {
FAIL("src size: got %d, want > 0", (int)(src.wi));
if (src.meta.wi <= 0) {
FAIL("src size: got %d, want > 0", (int)(src.meta.wi));
return false;
}
uint8_t literal_width = src.ptr[0];
uint8_t literal_width = src.data.ptr[0];
if (literal_width != 0x08) {
FAIL("LZW literal width: got %d, want %d", (int)(src.ptr[0]), 0x08);
FAIL("LZW literal width: got %d, want %d", (int)(src.data.ptr[0]), 0x08);
return false;
}
@@ -225,8 +230,8 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
uint64_t i;
uint64_t iters = iters_unscaled * iterscale;
for (i = 0; i < iters; i++) {
dst.wi = 0;
src.ri = 1; // Skip the literal width.
got.meta.wi = 0;
src.meta.ri = 1; // Skip the literal width.
wuffs_lzw__decoder dec = ((wuffs_lzw__decoder){});
wuffs_base__status z = wuffs_lzw__decoder__check_wuffs_version(
&dec, sizeof dec, WUFFS_VERSION);
@@ -234,12 +239,12 @@ bool do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) {
FAIL("check_wuffs_version: \"%s\"", z);
return false;
}
z = wuffs_lzw__decoder__decode(&dec, dst_writer, src_reader);
z = wuffs_lzw__decoder__decode(&dec, got_writer, src_reader);
if (z) {
FAIL("decode: \"%s\"", z);
return false;
}
n_bytes += dst.wi;
n_bytes += got.meta.wi;
}
bench_finish(iters, n_bytes);
return true;
+12 -10
View File
@@ -114,21 +114,23 @@ const char* wuffs_zlib_decode(wuffs_base__io_buffer* dst,
}
bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
if (!read_file(&src, zlib_midsummer_gt.src_filename)) {
return false;
}
// Flip a bit in the zlib checksum, which is in the last 4 bytes of the file.
if (src.wi < 4) {
if (src.meta.wi < 4) {
FAIL("source file was too short");
return false;
}
if (bad_checksum) {
src.ptr[src.wi - 1 - (bad_checksum & 3)] ^= 1;
src.data.ptr[src.meta.wi - 1 - (bad_checksum & 3)] ^= 1;
}
int end_limit;
@@ -141,9 +143,9 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
return false;
}
wuffs_zlib__decoder__set_ignore_checksum(&dec, ignore_checksum);
got.wi = 0;
got.meta.wi = 0;
wuffs_base__io_writer got_writer = wuffs_base__io_buffer__writer(&got);
src.ri = 0;
src.meta.ri = 0;
// Decode the src data in 1 or 2 chunks, depending on whether end_limit is
// or isn't zero.
@@ -155,11 +157,11 @@ bool do_test_wuffs_zlib_checksum(bool ignore_checksum, bool bad_checksum) {
if (end_limit == 0) {
continue;
}
if (src.wi < end_limit) {
if (src.meta.wi < end_limit) {
FAIL("end_limit=%d: not enough source data", end_limit);
return false;
}
set_reader_limit(&src_reader, src.wi - (uint64_t)(end_limit));
set_reader_limit(&src_reader, src.meta.wi - (uint64_t)(end_limit));
want_z = wuffs_base__suspension__short_read;
} else {
want_z = (bad_checksum && !ignore_checksum)
+71 -43
View File
@@ -23,11 +23,36 @@
#define WUFFS_TESTLIB_ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
uint8_t global_got_buffer[BUFFER_SIZE];
uint8_t global_want_buffer[BUFFER_SIZE];
uint8_t global_work_buffer[BUFFER_SIZE];
uint8_t global_src_buffer[BUFFER_SIZE];
uint8_t global_pixel_buffer[BUFFER_SIZE];
uint8_t global_got_array[BUFFER_SIZE];
uint8_t global_want_array[BUFFER_SIZE];
uint8_t global_work_array[BUFFER_SIZE];
uint8_t global_src_array[BUFFER_SIZE];
uint8_t global_pixel_array[BUFFER_SIZE];
wuffs_base__slice_u8 global_got_slice = ((wuffs_base__slice_u8){
.ptr = global_got_array,
.len = BUFFER_SIZE,
});
wuffs_base__slice_u8 global_want_slice = ((wuffs_base__slice_u8){
.ptr = global_want_array,
.len = BUFFER_SIZE,
});
wuffs_base__slice_u8 global_work_slice = ((wuffs_base__slice_u8){
.ptr = global_work_array,
.len = BUFFER_SIZE,
});
wuffs_base__slice_u8 global_src_slice = ((wuffs_base__slice_u8){
.ptr = global_src_array,
.len = BUFFER_SIZE,
});
wuffs_base__slice_u8 global_pixel_slice = ((wuffs_base__slice_u8){
.ptr = global_pixel_array,
.len = BUFFER_SIZE,
});
char fail_msg[65536] = {0};
@@ -304,8 +329,8 @@ wuffs_base__rect_ie_u32 make_rect_ie_u32(uint32_t x0,
void set_reader_limit(wuffs_base__io_reader* o, uint64_t limit) {
if (o && o->private_impl.buf) {
uint8_t* p = o->private_impl.buf->ptr + o->private_impl.buf->ri;
uint8_t* q = o->private_impl.buf->ptr + o->private_impl.buf->wi;
uint8_t* p = o->private_impl.buf->data.ptr + o->private_impl.buf->meta.ri;
uint8_t* q = o->private_impl.buf->data.ptr + o->private_impl.buf->meta.wi;
if (!o->private_impl.mark) {
o->private_impl.mark = p;
o->private_impl.limit = q;
@@ -318,8 +343,8 @@ void set_reader_limit(wuffs_base__io_reader* o, uint64_t limit) {
void set_writer_limit(wuffs_base__io_writer* o, uint64_t limit) {
if (o && o->private_impl.buf) {
uint8_t* p = o->private_impl.buf->ptr + o->private_impl.buf->wi;
uint8_t* q = o->private_impl.buf->ptr + o->private_impl.buf->len;
uint8_t* p = o->private_impl.buf->data.ptr + o->private_impl.buf->meta.wi;
uint8_t* q = o->private_impl.buf->data.ptr + o->private_impl.buf->data.len;
if (!o->private_impl.mark) {
o->private_impl.mark = p;
o->private_impl.limit = q;
@@ -345,11 +370,11 @@ const char* copy_to_io_buffer_from_pixel_buffer(wuffs_base__io_buffer* dst,
break;
}
uint32_t n = r.max_excl_x - r.min_incl_x;
if (n > (dst->len - dst->wi)) {
if (n > (dst->data.len - dst->meta.wi)) {
return "copy_to_io_buffer_from_pixel_buffer: dst buffer is too small";
}
memmove(dst->ptr + dst->wi, row.ptr + r.min_incl_x, n);
dst->wi += n;
memmove(dst->data.ptr + dst->meta.wi, row.ptr + r.min_incl_x, n);
dst->meta.wi += n;
}
}
return NULL;
@@ -360,7 +385,7 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) {
FAIL("read_file: NULL argument");
return false;
}
if (dst->closed) {
if (dst->meta.closed) {
FAIL("read_file: dst buffer closed for writes");
return false;
}
@@ -371,8 +396,8 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) {
}
uint8_t dummy[1];
uint8_t* ptr = dst->ptr + dst->wi;
size_t len = dst->len - dst->wi;
uint8_t* ptr = dst->data.ptr + dst->meta.wi;
size_t len = dst->data.len - dst->meta.wi;
while (true) {
if (!len) {
// We have read all that dst can hold. Check that we have read the full
@@ -384,7 +409,7 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) {
if (ptr != dummy) {
ptr += n;
len -= n;
dst->wi += n;
dst->meta.wi += n;
} else if (n) {
FAIL("read_file(\"%s\"): EOF not reached", path);
fclose(f);
@@ -406,8 +431,8 @@ bool read_file(wuffs_base__io_buffer* dst, const char* path) {
return false;
}
fclose(f);
dst->pos = 0;
dst->closed = true;
dst->meta.pos = 0;
dst->meta.closed = true;
return true;
}
@@ -416,7 +441,7 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
FAIL("hex_dump: NULL argument");
return NULL;
}
if (buf->wi == 0) {
if (buf->meta.wi == 0) {
return msg;
}
size_t base = i - (i & 15);
@@ -426,10 +451,10 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
continue;
}
size_t b = base + j;
if (b >= buf->wi) {
if (b >= buf->meta.wi) {
break;
}
size_t n = buf->wi - b;
size_t n = buf->meta.wi - b;
INCR_FAIL(msg, " %06zx:", b);
size_t k;
for (k = 0; k < 16; k++) {
@@ -437,7 +462,7 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
INCR_FAIL(msg, " ");
}
if (k < n) {
INCR_FAIL(msg, "%02x", buf->ptr[b + k]);
INCR_FAIL(msg, "%02x", buf->data.ptr[b + k]);
} else {
INCR_FAIL(msg, " ");
}
@@ -446,7 +471,7 @@ char* hex_dump(char* msg, wuffs_base__io_buffer* buf, size_t i) {
for (k = 0; k < 16; k++) {
char c = ' ';
if (k < n) {
c = buf->ptr[b + k];
c = buf->data.ptr[b + k];
if ((c < 0x20) || (0x7F <= c)) {
c = '.';
}
@@ -470,16 +495,16 @@ bool io_buffers_equal(const char* prefix,
}
char* msg = fail_msg;
size_t i;
size_t n = got->wi < want->wi ? got->wi : want->wi;
size_t n = got->meta.wi < want->meta.wi ? got->meta.wi : want->meta.wi;
for (i = 0; i < n; i++) {
if (got->ptr[i] != want->ptr[i]) {
if (got->data.ptr[i] != want->data.ptr[i]) {
break;
}
}
if (got->wi != want->wi) {
if (got->meta.wi != want->meta.wi) {
INCR_FAIL(msg, "%sio_buffers_equal: wi: got %zu, want %zu.\n", prefix,
got->wi, want->wi);
} else if (i < got->wi) {
got->meta.wi, want->meta.wi);
} else if (i < got->meta.wi) {
INCR_FAIL(msg, "%sio_buffers_equal: wi=%zu:\n", prefix, n);
} else {
return true;
@@ -520,15 +545,18 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
return false;
}
wuffs_base__io_buffer src =
((wuffs_base__io_buffer){.ptr = global_src_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer got =
((wuffs_base__io_buffer){.ptr = global_got_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer want =
((wuffs_base__io_buffer){.ptr = global_want_buffer, .len = BUFFER_SIZE});
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
.data = global_src_slice,
});
wuffs_base__io_buffer got = ((wuffs_base__io_buffer){
.data = global_got_slice,
});
wuffs_base__io_buffer want = ((wuffs_base__io_buffer){
.data = global_want_slice,
});
if (!gt->src_filename) {
src.closed = true;
src.meta.closed = true;
} else if (!read_file(&src, gt->src_filename)) {
return false;
}
@@ -537,12 +565,12 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
FAIL("inconsistent src_offsets");
return false;
}
if (gt->src_offset1 > src.wi) {
if (gt->src_offset1 > src.meta.wi) {
FAIL("src_offset1 too large");
return false;
}
src.ri = gt->src_offset0;
src.wi = gt->src_offset1;
src.meta.ri = gt->src_offset0;
src.meta.wi = gt->src_offset1;
}
if (bench) {
@@ -552,8 +580,8 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
uint64_t i;
uint64_t iters = iters_unscaled * iterscale;
for (i = 0; i < iters; i++) {
got.wi = 0;
src.ri = gt->src_offset0;
got.meta.wi = 0;
src.meta.ri = gt->src_offset0;
const char* s = codec_func(&got, &src, wlimit, rlimit);
if (s) {
FAIL("%s", s);
@@ -563,10 +591,10 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
case tc_neither:
break;
case tc_dst:
n_bytes += got.wi;
n_bytes += got.meta.wi;
break;
case tc_src:
n_bytes += src.ri - gt->src_offset0;
n_bytes += src.meta.ri - gt->src_offset0;
break;
}
}
@@ -576,7 +604,7 @@ bool proc_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*,
}
if (!gt->want_filename) {
want.closed = true;
want.meta.closed = true;
} else if (!read_file(&want, gt->want_filename)) {
return false;
}