mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-20 08:47:28 +01:00
Don't use designated initializers
Some C/C++ compilers, such as MSVC, don't always support them. They're also not supported by GCC's "g++ -std=c++11 -Wpedantic".
This commit is contained in:
1 parent
ef7aa0d980
commit
c4b8a6a4cc
19 files changed
+639
-516
No files matched your search
@@ -134,6 +134,13 @@ typedef struct {
|
||||
uint8_t private_impl;
|
||||
} wuffs_base__empty_struct;
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__make_empty_struct() {
|
||||
wuffs_base__empty_struct ret;
|
||||
ret.private_impl = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// wuffs_base__utility is a placeholder receiver type. It enables what Java
|
||||
// calls static methods, as opposed to regular methods.
|
||||
typedef struct {
|
||||
@@ -367,18 +374,47 @@ typedef WUFFS_BASE__TABLE(uint16_t) wuffs_base__table_u16;
|
||||
typedef WUFFS_BASE__TABLE(uint32_t) wuffs_base__table_u32;
|
||||
typedef WUFFS_BASE__TABLE(uint64_t) wuffs_base__table_u64;
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__make_slice_u8(uint8_t* ptr, size_t len) {
|
||||
wuffs_base__slice_u8 ret;
|
||||
ret.ptr = ptr;
|
||||
ret.len = len;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u16 //
|
||||
wuffs_base__make_slice_u16(uint16_t* ptr, size_t len) {
|
||||
wuffs_base__slice_u16 ret;
|
||||
ret.ptr = ptr;
|
||||
ret.len = len;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u32 //
|
||||
wuffs_base__make_slice_u32(uint32_t* ptr, size_t len) {
|
||||
wuffs_base__slice_u32 ret;
|
||||
ret.ptr = ptr;
|
||||
ret.len = len;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u64 //
|
||||
wuffs_base__make_slice_u64(uint64_t* ptr, size_t len) {
|
||||
wuffs_base__slice_u64 ret;
|
||||
ret.ptr = ptr;
|
||||
ret.len = len;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// wuffs_base__slice_u8__subslice_i returns s[i:].
|
||||
//
|
||||
// It returns an empty slice if i is out of bounds.
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {
|
||||
if ((i <= SIZE_MAX) && (i <= s.len)) {
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = s.ptr + i,
|
||||
.len = s.len - i,
|
||||
});
|
||||
return wuffs_base__make_slice_u8(s.ptr + i, s.len - i);
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__slice_u8__subslice_j returns s[:j].
|
||||
@@ -387,12 +423,9 @@ wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__slice_u8__subslice_j(wuffs_base__slice_u8 s, uint64_t j) {
|
||||
if ((j <= SIZE_MAX) && (j <= s.len)) {
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = s.ptr,
|
||||
.len = j,
|
||||
});
|
||||
return wuffs_base__make_slice_u8(s.ptr, j);
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// wuffs_base__slice_u8__subslice_ij returns s[i:j].
|
||||
@@ -403,12 +436,9 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
|
||||
uint64_t i,
|
||||
uint64_t j) {
|
||||
if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = s.ptr + i,
|
||||
.len = j - i,
|
||||
});
|
||||
return wuffs_base__make_slice_u8(s.ptr + i, j - i);
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// ---------------- Bureaucracy re -Wunused-function
|
||||
@@ -419,6 +449,11 @@ wuffs_base__acknowledge_potentially_unused_functions__core_public()
|
||||
|
||||
static inline void
|
||||
wuffs_base__acknowledge_potentially_unused_functions__core_public() {
|
||||
(void)(wuffs_base__make_empty_struct);
|
||||
(void)(wuffs_base__make_slice_u16);
|
||||
(void)(wuffs_base__make_slice_u32);
|
||||
(void)(wuffs_base__make_slice_u64);
|
||||
(void)(wuffs_base__make_slice_u8);
|
||||
(void)(wuffs_base__slice_u8__subslice_i);
|
||||
(void)(wuffs_base__slice_u8__subslice_ij);
|
||||
(void)(wuffs_base__slice_u8__subslice_j);
|
||||
@@ -1296,15 +1331,19 @@ wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {
|
||||
|
||||
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){.private_impl = {0}});
|
||||
wuffs_base__io_reader ret;
|
||||
ret.private_impl.buf = buf;
|
||||
ret.private_impl.mark = NULL;
|
||||
ret.private_impl.limit = NULL;
|
||||
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){.private_impl = {0}});
|
||||
wuffs_base__io_writer ret;
|
||||
ret.private_impl.buf = buf;
|
||||
ret.private_impl.mark = NULL;
|
||||
ret.private_impl.limit = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -1382,13 +1421,10 @@ wuffs_base__malloc_slice_u8(void* (*malloc_func)(size_t), uint64_t num_u8) {
|
||||
if (malloc_func && (num_u8 <= (SIZE_MAX / sizeof(uint8_t)))) {
|
||||
void* p = (*malloc_func)(num_u8 * sizeof(uint8_t));
|
||||
if (p) {
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = (uint8_t*)(p),
|
||||
.len = num_u8,
|
||||
});
|
||||
return wuffs_base__make_slice_u8((uint8_t*)(p), num_u8);
|
||||
}
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u16 //
|
||||
@@ -1396,13 +1432,10 @@ wuffs_base__malloc_slice_u16(void* (*malloc_func)(size_t), uint64_t num_u16) {
|
||||
if (malloc_func && (num_u16 <= (SIZE_MAX / sizeof(uint16_t)))) {
|
||||
void* p = (*malloc_func)(num_u16 * sizeof(uint16_t));
|
||||
if (p) {
|
||||
return ((wuffs_base__slice_u16){
|
||||
.ptr = (uint16_t*)(p),
|
||||
.len = num_u16,
|
||||
});
|
||||
return wuffs_base__make_slice_u16((uint16_t*)(p), num_u16);
|
||||
}
|
||||
}
|
||||
return ((wuffs_base__slice_u16){0});
|
||||
return wuffs_base__make_slice_u16(NULL, 0);
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u32 //
|
||||
@@ -1410,13 +1443,10 @@ wuffs_base__malloc_slice_u32(void* (*malloc_func)(size_t), uint64_t num_u32) {
|
||||
if (malloc_func && (num_u32 <= (SIZE_MAX / sizeof(uint32_t)))) {
|
||||
void* p = (*malloc_func)(num_u32 * sizeof(uint32_t));
|
||||
if (p) {
|
||||
return ((wuffs_base__slice_u32){
|
||||
.ptr = (uint32_t*)(p),
|
||||
.len = num_u32,
|
||||
});
|
||||
return wuffs_base__make_slice_u32((uint32_t*)(p), num_u32);
|
||||
}
|
||||
}
|
||||
return ((wuffs_base__slice_u32){0});
|
||||
return wuffs_base__make_slice_u32(NULL, 0);
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u64 //
|
||||
@@ -1424,13 +1454,10 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {
|
||||
if (malloc_func && (num_u64 <= (SIZE_MAX / sizeof(uint64_t)))) {
|
||||
void* p = (*malloc_func)(num_u64 * sizeof(uint64_t));
|
||||
if (p) {
|
||||
return ((wuffs_base__slice_u64){
|
||||
.ptr = (uint64_t*)(p),
|
||||
.len = num_u64,
|
||||
});
|
||||
return wuffs_base__make_slice_u64((uint64_t*)(p), num_u64);
|
||||
}
|
||||
}
|
||||
return ((wuffs_base__slice_u64){0});
|
||||
return wuffs_base__make_slice_u64(NULL, 0);
|
||||
}
|
||||
|
||||
// ---------------- Bureaucracy re -Wunused-function
|
||||
@@ -1801,17 +1828,20 @@ wuffs_base__pixel_config__set(wuffs_base__pixel_config* c,
|
||||
return;
|
||||
}
|
||||
}
|
||||
*c = ((wuffs_base__pixel_config){
|
||||
.private_impl = {0},
|
||||
});
|
||||
|
||||
c->private_impl.pixfmt = 0;
|
||||
c->private_impl.pixsub = 0;
|
||||
c->private_impl.width = 0;
|
||||
c->private_impl.height = 0;
|
||||
}
|
||||
|
||||
static inline void //
|
||||
wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {
|
||||
if (c) {
|
||||
*c = ((wuffs_base__pixel_config){
|
||||
.private_impl = {0},
|
||||
});
|
||||
c->private_impl.pixfmt = 0;
|
||||
c->private_impl.pixsub = 0;
|
||||
c->private_impl.width = 0;
|
||||
c->private_impl.height = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1832,13 +1862,21 @@ wuffs_base__pixel_config__pixel_subsampling(wuffs_base__pixel_config* c) {
|
||||
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__pixel_config__bounds(wuffs_base__pixel_config* c) {
|
||||
return c ? ((wuffs_base__rect_ie_u32){
|
||||
.min_incl_x = 0,
|
||||
.min_incl_y = 0,
|
||||
.max_excl_x = c->private_impl.width,
|
||||
.max_excl_y = c->private_impl.height,
|
||||
})
|
||||
: ((wuffs_base__rect_ie_u32){0});
|
||||
if (c) {
|
||||
wuffs_base__rect_ie_u32 ret;
|
||||
ret.min_incl_x = 0;
|
||||
ret.min_incl_y = 0;
|
||||
ret.max_excl_x = c->private_impl.width;
|
||||
ret.max_excl_y = c->private_impl.height;
|
||||
return ret;
|
||||
}
|
||||
|
||||
wuffs_base__rect_ie_u32 ret;
|
||||
ret.min_incl_x = 0;
|
||||
ret.min_incl_y = 0;
|
||||
ret.max_excl_x = 0;
|
||||
ret.max_excl_y = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
@@ -1988,19 +2026,24 @@ wuffs_base__image_config__set(wuffs_base__image_config* c,
|
||||
c->private_impl.first_frame_is_opaque = first_frame_is_opaque;
|
||||
return;
|
||||
}
|
||||
*c = ((wuffs_base__image_config){
|
||||
.pixcfg = {.private_impl = {0}},
|
||||
.private_impl = {0},
|
||||
});
|
||||
|
||||
c->pixcfg.private_impl.pixfmt = 0;
|
||||
c->pixcfg.private_impl.pixsub = 0;
|
||||
c->pixcfg.private_impl.width = 0;
|
||||
c->pixcfg.private_impl.height = 0;
|
||||
c->private_impl.first_frame_io_position = 0;
|
||||
c->private_impl.first_frame_is_opaque = 0;
|
||||
}
|
||||
|
||||
static inline void //
|
||||
wuffs_base__image_config__invalidate(wuffs_base__image_config* c) {
|
||||
if (c) {
|
||||
*c = ((wuffs_base__image_config){
|
||||
.pixcfg = {.private_impl = {0}},
|
||||
.private_impl = {0},
|
||||
});
|
||||
c->pixcfg.private_impl.pixfmt = 0;
|
||||
c->pixcfg.private_impl.pixsub = 0;
|
||||
c->pixcfg.private_impl.width = 0;
|
||||
c->pixcfg.private_impl.height = 0;
|
||||
c->private_impl.first_frame_io_position = 0;
|
||||
c->private_impl.first_frame_is_opaque = 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2147,7 +2190,16 @@ wuffs_base__frame_config__update(wuffs_base__frame_config* c,
|
||||
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__frame_config__bounds(wuffs_base__frame_config* c) {
|
||||
return c ? c->private_impl.bounds : ((wuffs_base__rect_ie_u32){0});
|
||||
if (c) {
|
||||
return c->private_impl.bounds;
|
||||
}
|
||||
|
||||
wuffs_base__rect_ie_u32 ret;
|
||||
ret.min_incl_x = 0;
|
||||
ret.min_incl_y = 0;
|
||||
ret.max_excl_x = 0;
|
||||
ret.max_excl_y = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
@@ -2345,13 +2397,10 @@ wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {
|
||||
wuffs_base__table_u8* tab =
|
||||
&b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
|
||||
if ((tab->width == 1024) && (tab->height == 1)) {
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = tab->ptr,
|
||||
.len = 1024,
|
||||
});
|
||||
return wuffs_base__make_slice_u8(tab->ptr, 1024);
|
||||
}
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
static inline wuffs_base__pixel_format //
|
||||
@@ -2364,9 +2413,16 @@ wuffs_base__pixel_buffer__pixel_format(wuffs_base__pixel_buffer* b) {
|
||||
|
||||
static inline wuffs_base__table_u8 //
|
||||
wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {
|
||||
return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))
|
||||
? b->private_impl.planes[p]
|
||||
: ((wuffs_base__table_u8){0});
|
||||
if (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX)) {
|
||||
return b->private_impl.planes[p];
|
||||
}
|
||||
|
||||
wuffs_base__table_u8 ret;
|
||||
ret.ptr = NULL;
|
||||
ret.width = 0;
|
||||
ret.height = 0;
|
||||
ret.stride = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -3851,7 +3907,7 @@ extern "C" {
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__ignore_status(wuffs_base__status z) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// WUFFS_BASE__MAGIC is a magic number to check that initializers are called.
|
||||
@@ -3918,11 +3974,6 @@ wuffs_base__ignore_status(wuffs_base__status z) {
|
||||
// inline attribute to guide optimizations such as inlining, to avoid the
|
||||
// -Wunused-function warning, and we like to compile with -Wall -Werror.
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__return_empty_struct() {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
}
|
||||
|
||||
// ---------------- Numeric Types
|
||||
|
||||
static inline uint8_t //
|
||||
@@ -4252,19 +4303,16 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__table_u8__row(wuffs_base__table_u8 t, uint32_t y) {
|
||||
if (y < t.height) {
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = t.ptr + (t.stride * y),
|
||||
.len = t.width,
|
||||
});
|
||||
return wuffs_base__make_slice_u8(t.ptr + (t.stride * y), t.width);
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// ---------------- Slices and Tables (Utility)
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__utility__null_slice_u8() {
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
// ---------------- Bureaucracy re -Wunused-function
|
||||
@@ -4291,7 +4339,6 @@ wuffs_base__acknowledge_potentially_unused_functions__core_private() {
|
||||
(void)(wuffs_base__load_u64be);
|
||||
(void)(wuffs_base__load_u64le);
|
||||
(void)(wuffs_base__load_u8be);
|
||||
(void)(wuffs_base__return_empty_struct);
|
||||
(void)(wuffs_base__slice_u8__copy_from_slice);
|
||||
(void)(wuffs_base__slice_u8__prefix);
|
||||
(void)(wuffs_base__slice_u8__suffix);
|
||||
@@ -4368,34 +4415,34 @@ wuffs_base__range_ie_u64__get_max_excl(const wuffs_base__range_ie_u64* r) {
|
||||
|
||||
static inline wuffs_base__range_ii_u32 //
|
||||
wuffs_base__utility__make_range_ii_u32(uint32_t min_incl, uint32_t max_incl) {
|
||||
return ((wuffs_base__range_ii_u32){
|
||||
.min_incl = min_incl,
|
||||
.max_incl = max_incl,
|
||||
});
|
||||
wuffs_base__range_ii_u32 ret;
|
||||
ret.min_incl = min_incl;
|
||||
ret.max_incl = max_incl;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ie_u32 //
|
||||
wuffs_base__utility__make_range_ie_u32(uint32_t min_incl, uint32_t max_excl) {
|
||||
return ((wuffs_base__range_ie_u32){
|
||||
.min_incl = min_incl,
|
||||
.max_excl = max_excl,
|
||||
});
|
||||
wuffs_base__range_ie_u32 ret;
|
||||
ret.min_incl = min_incl;
|
||||
ret.max_excl = max_excl;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ii_u64 //
|
||||
wuffs_base__utility__make_range_ii_u64(uint64_t min_incl, uint64_t max_incl) {
|
||||
return ((wuffs_base__range_ii_u64){
|
||||
.min_incl = min_incl,
|
||||
.max_incl = max_incl,
|
||||
});
|
||||
wuffs_base__range_ii_u64 ret;
|
||||
ret.min_incl = min_incl;
|
||||
ret.max_incl = max_incl;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ie_u64 //
|
||||
wuffs_base__utility__make_range_ie_u64(uint64_t min_incl, uint64_t max_excl) {
|
||||
return ((wuffs_base__range_ie_u64){
|
||||
.min_incl = min_incl,
|
||||
.max_excl = max_excl,
|
||||
});
|
||||
wuffs_base__range_ie_u64 ret;
|
||||
ret.min_incl = min_incl;
|
||||
ret.max_excl = max_excl;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__rect_ii_u32 //
|
||||
@@ -4403,12 +4450,12 @@ wuffs_base__utility__make_rect_ii_u32(uint32_t min_incl_x,
|
||||
uint32_t min_incl_y,
|
||||
uint32_t max_incl_x,
|
||||
uint32_t max_incl_y) {
|
||||
return ((wuffs_base__rect_ii_u32){
|
||||
.min_incl_x = min_incl_x,
|
||||
.min_incl_y = min_incl_y,
|
||||
.max_incl_x = max_incl_x,
|
||||
.max_incl_y = max_incl_y,
|
||||
});
|
||||
wuffs_base__rect_ii_u32 ret;
|
||||
ret.min_incl_x = min_incl_x;
|
||||
ret.min_incl_y = min_incl_y;
|
||||
ret.max_incl_x = max_incl_x;
|
||||
ret.max_incl_y = max_incl_y;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
@@ -4416,12 +4463,12 @@ wuffs_base__utility__make_rect_ie_u32(uint32_t min_incl_x,
|
||||
uint32_t min_incl_y,
|
||||
uint32_t max_excl_x,
|
||||
uint32_t max_excl_y) {
|
||||
return ((wuffs_base__rect_ie_u32){
|
||||
.min_incl_x = min_incl_x,
|
||||
.min_incl_y = min_incl_y,
|
||||
.max_excl_x = max_excl_x,
|
||||
.max_excl_y = max_excl_y,
|
||||
});
|
||||
wuffs_base__rect_ie_u32 ret;
|
||||
ret.min_incl_x = min_incl_x;
|
||||
ret.min_incl_y = min_incl_y;
|
||||
ret.max_excl_x = max_excl_x;
|
||||
ret.max_excl_y = max_excl_y;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// ---------------- Bureaucracy re -Wunused-function
|
||||
@@ -4639,7 +4686,10 @@ wuffs_base__io_reader__set(wuffs_base__io_reader* o,
|
||||
o->private_impl.limit = data.ptr + data.len;
|
||||
*ptr_iop_r = data.ptr;
|
||||
*ptr_io1_r = data.ptr + data.len;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
|
||||
wuffs_base__empty_struct ret;
|
||||
ret.private_impl = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
@@ -4649,13 +4699,19 @@ wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,
|
||||
if (o && (((size_t)(o->private_impl.limit - iop_r)) > limit)) {
|
||||
o->private_impl.limit = iop_r + limit;
|
||||
}
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
|
||||
wuffs_base__empty_struct ret;
|
||||
ret.private_impl = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {
|
||||
o->private_impl.mark = mark;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
|
||||
wuffs_base__empty_struct ret;
|
||||
ret.private_impl = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
@@ -4663,12 +4719,9 @@ wuffs_base__io_reader__take(uint8_t** ptr_iop_r, uint8_t* io1_r, uint64_t n) {
|
||||
if (n <= ((size_t)(io1_r - *ptr_iop_r))) {
|
||||
uint8_t* p = *ptr_iop_r;
|
||||
*ptr_iop_r += n;
|
||||
return ((wuffs_base__slice_u8){
|
||||
.ptr = p,
|
||||
.len = n,
|
||||
});
|
||||
return wuffs_base__make_slice_u8(p, n);
|
||||
}
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
@@ -4688,25 +4741,51 @@ wuffs_base__io_writer__set(wuffs_base__io_writer* o,
|
||||
o->private_impl.limit = data.ptr + data.len;
|
||||
*ptr_iop_w = data.ptr;
|
||||
*ptr_io1_w = data.ptr + data.len;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
|
||||
wuffs_base__empty_struct ret;
|
||||
ret.private_impl = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {
|
||||
o->private_impl.mark = mark;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
|
||||
wuffs_base__empty_struct ret;
|
||||
ret.private_impl = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// ---------------- I/O (Utility)
|
||||
|
||||
static inline wuffs_base__io_buffer //
|
||||
wuffs_base__utility__null_io_buffer() {
|
||||
wuffs_base__io_buffer ret;
|
||||
ret.data.ptr = NULL;
|
||||
ret.data.len = 0;
|
||||
ret.meta.wi = 0;
|
||||
ret.meta.ri = 0;
|
||||
ret.meta.pos = 0;
|
||||
ret.meta.closed = false;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_reader //
|
||||
wuffs_base__utility__null_io_reader() {
|
||||
return ((wuffs_base__io_reader){.private_impl = {0}});
|
||||
wuffs_base__io_reader ret;
|
||||
ret.private_impl.buf = NULL;
|
||||
ret.private_impl.mark = NULL;
|
||||
ret.private_impl.limit = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline wuffs_base__io_writer //
|
||||
wuffs_base__utility__null_io_writer() {
|
||||
return ((wuffs_base__io_writer){.private_impl = {0}});
|
||||
wuffs_base__io_writer ret;
|
||||
ret.private_impl.buf = NULL;
|
||||
ret.private_impl.mark = NULL;
|
||||
ret.private_impl.limit = NULL;
|
||||
return ret;
|
||||
}
|
||||
|
||||
// ---------------- Bureaucracy re -Wunused-function
|
||||
@@ -4732,6 +4811,7 @@ wuffs_base__acknowledge_potentially_unused_functions__io_private() {
|
||||
(void)(wuffs_base__io_writer__is_valid);
|
||||
(void)(wuffs_base__io_writer__set);
|
||||
(void)(wuffs_base__io_writer__set_mark);
|
||||
(void)(wuffs_base__utility__null_io_buffer);
|
||||
(void)(wuffs_base__utility__null_io_reader);
|
||||
(void)(wuffs_base__utility__null_io_writer);
|
||||
}
|
||||
@@ -6366,11 +6446,11 @@ sizeof__wuffs_deflate__decoder() {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_deflate__decoder__workbuf_len(const wuffs_deflate__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_range_ii_u64(1, 1);
|
||||
@@ -6453,35 +6533,25 @@ wuffs_deflate__decoder__decode_io_writer(wuffs_deflate__decoder* self,
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
v_written = ((wuffs_base__slice_u8){
|
||||
.ptr = a_dst.private_impl.mark,
|
||||
.len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
|
||||
});
|
||||
v_written = wuffs_base__make_slice_u8(
|
||||
a_dst.private_impl.mark,
|
||||
(size_t)(iop_a_dst - a_dst.private_impl.mark));
|
||||
if (((uint64_t)(v_written.len)) >= 32768) {
|
||||
v_written = wuffs_base__slice_u8__suffix(v_written, 32768);
|
||||
wuffs_base__slice_u8__copy_from_slice(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history, 32768),
|
||||
v_written);
|
||||
self->private_impl.f_history_index = 32768;
|
||||
} else {
|
||||
v_n_copied = wuffs_base__slice_u8__copy_from_slice(
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history, 32768),
|
||||
(self->private_impl.f_history_index & 32767)),
|
||||
v_written);
|
||||
if (v_n_copied < ((uint64_t)(v_written.len))) {
|
||||
v_written = wuffs_base__slice_u8__subslice_i(v_written, v_n_copied);
|
||||
v_n_copied = wuffs_base__slice_u8__copy_from_slice(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history, 32768),
|
||||
v_written);
|
||||
self->private_impl.f_history_index =
|
||||
(((uint32_t)((v_n_copied & 32767))) + 32768);
|
||||
@@ -7415,10 +7485,10 @@ label_0_continue:;
|
||||
(((uint64_t)(io1_a_src - iop_a_src)) >= 12)) {
|
||||
if (v_n_bits < 15) {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
} else {
|
||||
}
|
||||
@@ -7429,7 +7499,7 @@ label_0_continue:;
|
||||
if ((v_table_entry >> 31) != 0) {
|
||||
(wuffs_base__store_u8be(iop_a_dst,
|
||||
((uint8_t)(((v_table_entry >> 8) & 255)))),
|
||||
iop_a_dst += 1, wuffs_base__return_empty_struct());
|
||||
iop_a_dst += 1, wuffs_base__make_empty_struct());
|
||||
goto label_0_continue;
|
||||
} else if ((v_table_entry >> 30) != 0) {
|
||||
} else if ((v_table_entry >> 29) != 0) {
|
||||
@@ -7438,10 +7508,10 @@ label_0_continue:;
|
||||
} else if ((v_table_entry >> 28) != 0) {
|
||||
if (v_n_bits < 15) {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
} else {
|
||||
}
|
||||
@@ -7460,7 +7530,7 @@ label_0_continue:;
|
||||
if ((v_table_entry >> 31) != 0) {
|
||||
(wuffs_base__store_u8be(iop_a_dst,
|
||||
((uint8_t)(((v_table_entry >> 8) & 255)))),
|
||||
iop_a_dst += 1, wuffs_base__return_empty_struct());
|
||||
iop_a_dst += 1, wuffs_base__make_empty_struct());
|
||||
goto label_0_continue;
|
||||
} else if ((v_table_entry >> 30) != 0) {
|
||||
} else if ((v_table_entry >> 29) != 0) {
|
||||
@@ -7491,10 +7561,10 @@ label_0_continue:;
|
||||
if (v_table_entry_n_bits > 0) {
|
||||
if (v_n_bits < 15) {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
} else {
|
||||
}
|
||||
@@ -7509,10 +7579,10 @@ label_0_continue:;
|
||||
}
|
||||
if (v_n_bits < 15) {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
} else {
|
||||
}
|
||||
@@ -7523,10 +7593,10 @@ label_0_continue:;
|
||||
if ((v_table_entry >> 28) == 1) {
|
||||
if (v_n_bits < 15) {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
} else {
|
||||
}
|
||||
@@ -7557,10 +7627,10 @@ label_0_continue:;
|
||||
v_table_entry_n_bits = ((v_table_entry >> 4) & 15);
|
||||
if (v_n_bits < v_table_entry_n_bits) {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
}
|
||||
v_dist_minus_1 =
|
||||
@@ -7593,10 +7663,8 @@ label_0_continue:;
|
||||
v_n_copied = wuffs_base__io_writer__copy_n_from_slice(
|
||||
&iop_a_dst, io1_a_dst, v_hlen,
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history,
|
||||
32768),
|
||||
(v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
goto label_1_break;
|
||||
@@ -7604,10 +7672,7 @@ label_0_continue:;
|
||||
v_hlen -= v_n_copied;
|
||||
wuffs_base__io_writer__copy_n_from_slice(
|
||||
&iop_a_dst, io1_a_dst, v_hlen,
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}));
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history, 32768));
|
||||
goto label_1_break;
|
||||
}
|
||||
label_1_break:;
|
||||
@@ -7631,7 +7696,7 @@ label_0_break:;
|
||||
while (v_n_bits >= 8) {
|
||||
v_n_bits -= 8;
|
||||
if (iop_a_src > io0_a_src) {
|
||||
(iop_a_src--, wuffs_base__return_empty_struct());
|
||||
(iop_a_src--, wuffs_base__make_empty_struct());
|
||||
} else {
|
||||
status = wuffs_deflate__error__internal_error_inconsistent_i_o;
|
||||
goto exit;
|
||||
@@ -7976,10 +8041,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
|
||||
v_n_copied = wuffs_base__io_writer__copy_n_from_slice(
|
||||
&iop_a_dst, io1_a_dst, v_hlen,
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history,
|
||||
32768),
|
||||
(v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
@@ -8001,10 +8064,8 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
|
||||
v_n_copied = wuffs_base__io_writer__copy_n_from_slice(
|
||||
&iop_a_dst, io1_a_dst, v_hlen,
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_history,
|
||||
32768),
|
||||
(v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
@@ -8173,18 +8234,18 @@ sizeof__wuffs_lzw__decoder() {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct //
|
||||
wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (a_lw < 2 || a_lw > 8) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
self->private_impl.f_set_literal_width_arg = a_lw;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func lzw.decoder.workbuf_len
|
||||
@@ -8192,11 +8253,11 @@ wuffs_lzw__decoder__set_literal_width(wuffs_lzw__decoder* self, uint32_t a_lw) {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_lzw__decoder__workbuf_len(const wuffs_lzw__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
@@ -8348,15 +8409,14 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self,
|
||||
if (v_n_bits < v_width) {
|
||||
if (((uint64_t)(io1_a_src - iop_a_src)) >= 4) {
|
||||
v_bits |= (wuffs_base__load_u32le(iop_a_src) << v_n_bits);
|
||||
(iop_a_src += ((31 - v_n_bits) >> 3),
|
||||
wuffs_base__return_empty_struct());
|
||||
(iop_a_src += ((31 - v_n_bits) >> 3), wuffs_base__make_empty_struct());
|
||||
v_n_bits |= 24;
|
||||
} else if (((uint64_t)(io1_a_src - iop_a_src)) <= 0) {
|
||||
self->private_impl.f_read_from_return_value = 2;
|
||||
goto label_0_break;
|
||||
} else {
|
||||
v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
if (v_n_bits >= v_width) {
|
||||
} else if (((uint64_t)(io1_a_src - iop_a_src)) <= 0) {
|
||||
@@ -8365,7 +8425,7 @@ wuffs_lzw__decoder__read_from(wuffs_lzw__decoder* self,
|
||||
} else {
|
||||
v_bits |=
|
||||
(((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits);
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
v_n_bits += 8;
|
||||
if (v_n_bits < v_width) {
|
||||
self->private_impl.f_read_from_return_value = 4;
|
||||
@@ -8475,7 +8535,7 @@ label_0_break:;
|
||||
while (v_n_bits >= 8) {
|
||||
v_n_bits -= 8;
|
||||
if (iop_a_src > io0_a_src) {
|
||||
(iop_a_src--, wuffs_base__return_empty_struct());
|
||||
(iop_a_src--, wuffs_base__make_empty_struct());
|
||||
} else {
|
||||
self->private_impl.f_read_from_return_value = 4;
|
||||
goto label_2_break;
|
||||
@@ -8494,7 +8554,7 @@ label_0_break:;
|
||||
iop_a_src - a_src.private_impl.buf->data.ptr;
|
||||
}
|
||||
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func lzw.decoder.write_to
|
||||
@@ -8537,10 +8597,7 @@ wuffs_lzw__decoder__write_to(wuffs_lzw__decoder* self,
|
||||
goto exit;
|
||||
}
|
||||
v_s = wuffs_base__slice_u8__subslice_ij(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_output,
|
||||
.len = 8199,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_output, 8199),
|
||||
self->private_impl.f_output_ri, self->private_impl.f_output_wi);
|
||||
v_n = wuffs_base__io_writer__copy_from_slice(&iop_a_dst, io1_a_dst, v_s);
|
||||
if (v_n == ((uint64_t)(v_s.len))) {
|
||||
@@ -8581,20 +8638,17 @@ exit:
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__slice_u8 //
|
||||
wuffs_lzw__decoder__flush(wuffs_lzw__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return ((wuffs_base__slice_u8){0});
|
||||
return wuffs_base__make_slice_u8(NULL, 0);
|
||||
}
|
||||
|
||||
wuffs_base__slice_u8 v_s = {0};
|
||||
|
||||
if (self->private_impl.f_output_ri <= self->private_impl.f_output_wi) {
|
||||
v_s = wuffs_base__slice_u8__subslice_ij(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_output,
|
||||
.len = 8199,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_output, 8199),
|
||||
self->private_impl.f_output_ri, self->private_impl.f_output_wi);
|
||||
}
|
||||
self->private_impl.f_output_ri = 0;
|
||||
@@ -8906,11 +8960,11 @@ wuffs_gif__decoder__num_decoded_frames(const wuffs_gif__decoder* self) {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 //
|
||||
wuffs_gif__decoder__frame_dirty_rect(const wuffs_gif__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__rect_ie_u32){0});
|
||||
return wuffs_base__utility__make_rect_ie_u32(0, 0, 0, 0);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return ((wuffs_base__rect_ie_u32){0});
|
||||
return wuffs_base__utility__make_rect_ie_u32(0, 0, 0, 0);
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_rect_ie_u32(
|
||||
@@ -8927,11 +8981,11 @@ wuffs_gif__decoder__frame_dirty_rect(const wuffs_gif__decoder* self) {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_gif__decoder__workbuf_len(const wuffs_gif__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_range_ii_u64(1, 1);
|
||||
@@ -8995,7 +9049,7 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
(memset(&self->private_impl.f_dirty_y, 0, sizeof(wuffs_base__range_ie_u32)),
|
||||
wuffs_base__return_empty_struct());
|
||||
wuffs_base__make_empty_struct());
|
||||
if (!self->private_impl.f_end_of_data) {
|
||||
if (self->private_impl.f_call_sequence == 0) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
@@ -9245,7 +9299,7 @@ wuffs_gif__decoder__reset_gc(wuffs_gif__decoder* self) {
|
||||
self->private_impl.f_gc_transparent_index = 0;
|
||||
self->private_impl.f_gc_disposal = 0;
|
||||
self->private_impl.f_gc_duration = 0;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.decode_up_to_id_part1
|
||||
@@ -10439,14 +10493,8 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
}
|
||||
} else if (self->private_impl.f_gc_has_transparent_index) {
|
||||
wuffs_base__slice_u8__copy_from_slice(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_palettes[1],
|
||||
.len = 1024,
|
||||
}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_palettes[0],
|
||||
.len = 1024,
|
||||
}));
|
||||
wuffs_base__make_slice_u8(self->private_data.f_palettes[1], 1024),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_palettes[0], 1024));
|
||||
} else {
|
||||
self->private_impl.f_which_palette = 0;
|
||||
}
|
||||
@@ -10466,20 +10514,16 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
}
|
||||
v_dst_palette = wuffs_base__pixel_buffer__palette(a_dst);
|
||||
if (((uint64_t)(v_dst_palette.len)) == 0) {
|
||||
v_dst_palette = ((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_dst_palette,
|
||||
.len = 1024,
|
||||
});
|
||||
v_dst_palette =
|
||||
wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024);
|
||||
}
|
||||
wuffs_base__pixel_swizzler__prepare(
|
||||
&self->private_impl.f_swizzler,
|
||||
wuffs_base__pixel_buffer__pixel_format(a_dst), v_dst_palette,
|
||||
1191444488,
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data
|
||||
.f_palettes[self->private_impl.f_which_palette],
|
||||
.len = 1024,
|
||||
}));
|
||||
wuffs_base__make_slice_u8(
|
||||
self->private_data.f_palettes[self->private_impl.f_which_palette],
|
||||
1024));
|
||||
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
|
||||
wuffs_base__ignore_status(wuffs_lzw__decoder__initialize(
|
||||
&self->private_data.f_lzw, sizeof(wuffs_lzw__decoder), WUFFS_VERSION,
|
||||
@@ -10538,11 +10582,9 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self,
|
||||
bool v_need_block_size = false;
|
||||
uint64_t v_n_compressed = 0;
|
||||
wuffs_base__slice_u8 v_compressed = {0};
|
||||
wuffs_base__io_reader v_r = {.private_impl = {0}};
|
||||
wuffs_base__io_buffer u_r WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
.data = ((wuffs_base__slice_u8){0}),
|
||||
.meta = ((wuffs_base__io_buffer_meta){0}),
|
||||
};
|
||||
wuffs_base__io_reader v_r = wuffs_base__utility__null_io_reader();
|
||||
wuffs_base__io_buffer u_r WUFFS_BASE__POTENTIALLY_UNUSED =
|
||||
wuffs_base__utility__null_io_buffer();
|
||||
uint8_t* iop_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
uint8_t* io1_v_r WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
wuffs_base__status v_lzw_status = NULL;
|
||||
@@ -10611,10 +10653,8 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self,
|
||||
wuffs_base__io_reader__take(&iop_a_src, io1_a_src, v_n_compressed);
|
||||
wuffs_base__slice_u8__copy_from_slice(
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_compressed,
|
||||
.len = 4096,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_compressed,
|
||||
4096),
|
||||
self->private_impl.f_compressed_wi),
|
||||
v_compressed);
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_compressed_wi,
|
||||
@@ -10628,7 +10668,7 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self,
|
||||
goto label_1_break;
|
||||
}
|
||||
v_block_size = ((uint64_t)(wuffs_base__load_u8be(iop_a_src)));
|
||||
(iop_a_src += 1, wuffs_base__return_empty_struct());
|
||||
(iop_a_src += 1, wuffs_base__make_empty_struct());
|
||||
}
|
||||
label_1_break:;
|
||||
if (1 > ((uint64_t)(a_workbuf.len))) {
|
||||
@@ -10650,10 +10690,8 @@ wuffs_gif__decoder__decode_id_part2(wuffs_gif__decoder* self,
|
||||
wuffs_base__io_reader__set(
|
||||
&v_r, &u_r, &iop_v_r, &io1_v_r,
|
||||
wuffs_base__slice_u8__subslice_ij(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_compressed,
|
||||
.len = 4096,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_compressed,
|
||||
4096),
|
||||
self->private_impl.f_compressed_ri,
|
||||
self->private_impl.f_compressed_wi));
|
||||
{
|
||||
@@ -10804,10 +10842,7 @@ label_0_continue:;
|
||||
}
|
||||
v_n = wuffs_base__pixel_swizzler__swizzle_packed(
|
||||
&self->private_impl.f_swizzler, v_dst,
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_data.f_dst_palette,
|
||||
.len = 1024,
|
||||
}),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024),
|
||||
v_src);
|
||||
wuffs_base__u64__sat_add_indirect(&v_src_ri, v_n);
|
||||
wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x,
|
||||
@@ -10971,14 +11006,14 @@ sizeof__wuffs_gzip__decoder() {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct //
|
||||
wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
self->private_impl.f_ignore_checksum = a_ic;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func gzip.decoder.workbuf_len
|
||||
@@ -10986,11 +11021,11 @@ wuffs_gzip__decoder__set_ignore_checksum(wuffs_gzip__decoder* self, bool a_ic) {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_gzip__decoder__workbuf_len(const wuffs_gzip__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_range_ii_u64(1, 1);
|
||||
@@ -11249,10 +11284,9 @@ wuffs_gzip__decoder__decode_io_writer(wuffs_gzip__decoder* self,
|
||||
if (!self->private_impl.f_ignore_checksum) {
|
||||
v_checksum_got = wuffs_crc32__ieee_hasher__update(
|
||||
&self->private_data.f_checksum,
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = a_dst.private_impl.mark,
|
||||
.len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
|
||||
}));
|
||||
wuffs_base__make_slice_u8(
|
||||
a_dst.private_impl.mark,
|
||||
(size_t)(iop_a_dst - a_dst.private_impl.mark)));
|
||||
v_decoded_length_got += ((uint32_t)(
|
||||
(((uint64_t)(iop_a_dst - a_dst.private_impl.mark)) & 4294967295)));
|
||||
}
|
||||
@@ -11466,14 +11500,14 @@ sizeof__wuffs_zlib__decoder() {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct //
|
||||
wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
self->private_impl.f_ignore_checksum = a_ic;
|
||||
return ((wuffs_base__empty_struct){0});
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func zlib.decoder.workbuf_len
|
||||
@@ -11481,11 +11515,11 @@ wuffs_zlib__decoder__set_ignore_checksum(wuffs_zlib__decoder* self, bool a_ic) {
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_zlib__decoder__workbuf_len(const wuffs_zlib__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return ((wuffs_base__range_ii_u64){0});
|
||||
return wuffs_base__utility__make_range_ii_u64(0, 0);
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_range_ii_u64(1, 1);
|
||||
@@ -11629,10 +11663,9 @@ wuffs_zlib__decoder__decode_io_writer(wuffs_zlib__decoder* self,
|
||||
if (!self->private_impl.f_ignore_checksum) {
|
||||
v_checksum_got = wuffs_adler32__hasher__update(
|
||||
&self->private_data.f_checksum,
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = a_dst.private_impl.mark,
|
||||
.len = (size_t)(iop_a_dst - a_dst.private_impl.mark),
|
||||
}));
|
||||
wuffs_base__make_slice_u8(
|
||||
a_dst.private_impl.mark,
|
||||
(size_t)(iop_a_dst - a_dst.private_impl.mark)));
|
||||
}
|
||||
if (wuffs_base__status__is_ok(v_status)) {
|
||||
goto label_0_break;
|
||||
|
||||
Reference in new issue
Block a user