mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
wuffs gen -version=0.2.0-alpha.17
This commit is contained in:
1 parent
ead965c61f
commit
5894b9448c
1 file changed
+223
-134
+223
-134
@@ -65,14 +65,14 @@ extern "C" {
|
||||
// work-in-progress version, not a release version, and has no backwards or
|
||||
// forwards compatibility guarantees.
|
||||
//
|
||||
// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-09-02 UTC,
|
||||
// based on revision 555a72d7a9e0fa3a2ecc810b2af820252f9c4fdf.
|
||||
// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-09-08 UTC,
|
||||
// based on revision ead965c61fc81478be59d13033b62f3c4d45ea04.
|
||||
#define WUFFS_VERSION ((uint64_t)0x0000000000020000)
|
||||
#define WUFFS_VERSION_MAJOR ((uint64_t)0x00000000)
|
||||
#define WUFFS_VERSION_MINOR ((uint64_t)0x0002)
|
||||
#define WUFFS_VERSION_PATCH ((uint64_t)0x0000)
|
||||
#define WUFFS_VERSION_EXTENSION "alpha.16"
|
||||
#define WUFFS_VERSION_STRING "0.2.0-alpha.16"
|
||||
#define WUFFS_VERSION_EXTENSION "alpha.17"
|
||||
#define WUFFS_VERSION_STRING "0.2.0-alpha.17"
|
||||
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
|
||||
// static storage. The motivation is discussed in the "ALLOW STATIC
|
||||
@@ -142,7 +142,7 @@ extern const char* wuffs_base__error__bad_call_sequence;
|
||||
extern const char* wuffs_base__error__bad_receiver;
|
||||
extern const char* wuffs_base__error__bad_restart;
|
||||
extern const char* wuffs_base__error__bad_sizeof_receiver;
|
||||
extern const char* wuffs_base__error__bad_work_buffer_length;
|
||||
extern const char* wuffs_base__error__bad_workbuf_length;
|
||||
extern const char* wuffs_base__error__bad_wuffs_version;
|
||||
extern const char* wuffs_base__error__cannot_return_a_suspension;
|
||||
extern const char* wuffs_base__error__check_wuffs_version_not_applicable;
|
||||
@@ -1048,6 +1048,8 @@ typedef struct wuffs_base__io_buffer__struct {
|
||||
|
||||
#ifdef __cplusplus
|
||||
inline void compact();
|
||||
inline uint64_t io_position_reader();
|
||||
inline uint64_t io_position_writer();
|
||||
inline wuffs_base__io_reader reader();
|
||||
inline wuffs_base__io_writer writer();
|
||||
#endif // __cplusplus
|
||||
@@ -1070,6 +1072,16 @@ wuffs_base__io_buffer__compact(wuffs_base__io_buffer* buf) {
|
||||
buf->ri = 0;
|
||||
}
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_base__io_buffer__io_position_reader(wuffs_base__io_buffer* buf) {
|
||||
return buf ? wuffs_base__u64__sat_add(buf->pos, buf->ri) : 0;
|
||||
}
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_base__io_buffer__io_position_writer(wuffs_base__io_buffer* buf) {
|
||||
return buf ? wuffs_base__u64__sat_add(buf->pos, buf->wi) : 0;
|
||||
}
|
||||
|
||||
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){});
|
||||
@@ -1091,6 +1103,16 @@ wuffs_base__io_buffer__struct::compact() {
|
||||
wuffs_base__io_buffer__compact(this);
|
||||
}
|
||||
|
||||
inline uint64_t //
|
||||
wuffs_base__io_buffer__struct::io_position_reader() {
|
||||
return wuffs_base__io_buffer__io_position_reader(this);
|
||||
}
|
||||
|
||||
inline uint64_t //
|
||||
wuffs_base__io_buffer__struct::io_position_writer() {
|
||||
return wuffs_base__io_buffer__io_position_writer(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__io_reader //
|
||||
wuffs_base__io_buffer__struct::reader() {
|
||||
return wuffs_base__io_buffer__reader(this);
|
||||
@@ -1140,11 +1162,13 @@ typedef uint32_t wuffs_base__color_u32argb;
|
||||
// - bits 30 .. 28 encodes color (and channel order, in terms of memory).
|
||||
// - bits 27 .. 26 are reserved.
|
||||
// - bits 25 .. 24 encodes transparency.
|
||||
// - bit 23 indicates big-endian/MSB-first (as opposed to little/LSB).
|
||||
// - bit 22 indicates floating point (as opposed to integer).
|
||||
// - bits 21 .. 20 are the number of planes, minus 1. Zero means packed.
|
||||
// - bits 19 .. 16 encodes the number of bits (depth) in an index value.
|
||||
// Zero means direct, not palette-indexed.
|
||||
// - bits 23 .. 21 are reserved.
|
||||
// - bit 20 indicates big-endian/MSB-first (as opposed to little/LSB).
|
||||
// - bit 19 indicates floating point (as opposed to integer).
|
||||
// - bit 18 indicates palette-indexed. The number-of-planes (the next
|
||||
// field) will be zero, as the format is considered packed,
|
||||
// but the 8-bit N-BGRA color data is stored in plane 3.
|
||||
// - bits 17 .. 16 are the number of planes, minus 1. Zero means packed.
|
||||
// - bits 15 .. 12 encodes the number of bits (depth) in the 3rd channel.
|
||||
// - bits 11 .. 8 encodes the number of bits (depth) in the 2nd channel.
|
||||
// - bits 7 .. 4 encodes the number of bits (depth) in the 1st channel.
|
||||
@@ -1163,10 +1187,12 @@ typedef uint32_t wuffs_base__color_u32argb;
|
||||
// For direct formats with N > 1 channels, those channels can be laid out in
|
||||
// either 1 (packed) or N (planar) planes. For example, RGBA data is usually
|
||||
// packed, but YUV data is usually planar, due to chroma subsampling (for
|
||||
// details, see the wuffs_base__pixel_subsampling type). For indexed formats,
|
||||
// the palette (always 256 × 4 bytes) holds up to 4 packed bytes of color data
|
||||
// per index value, and there is only 1 plane (for the index). The distance
|
||||
// between successive palette elements is always 4 bytes.
|
||||
// details, see the wuffs_base__pixel_subsampling type).
|
||||
//
|
||||
// For indexed formats, the palette (always 256 × 4 bytes) holds 8 bits per
|
||||
// channel non-alpha-premultiplied BGRA color data. There is only 1 plane (for
|
||||
// the index), as the format is considered packed. Plane 0 holds the per-pixel
|
||||
// indices. Plane 3 is re-purposed to hold the per-index colors.
|
||||
//
|
||||
// The color field is encoded in 3 bits:
|
||||
// - 0 means A (Alpha).
|
||||
@@ -1205,7 +1231,7 @@ typedef uint32_t wuffs_base__color_u32argb;
|
||||
// - 14 means a bit depth of 48.
|
||||
// - 15 means a bit depth of 64.
|
||||
//
|
||||
// For example, wuffs_base__pixel_format 0x3280BBBB is a natural format for
|
||||
// For example, wuffs_base__pixel_format 0x3210BBBB is a natural format for
|
||||
// decoding a PNG image - network byte order (also known as big-endian),
|
||||
// packed, non-premultiplied alpha - that happens to be 16-bit-depth truecolor
|
||||
// with alpha (RGBA). In memory order:
|
||||
@@ -1255,35 +1281,30 @@ typedef uint32_t wuffs_base__pixel_format;
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__YA_PREMUL \
|
||||
((wuffs_base__pixel_format)0x13000008)
|
||||
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL \
|
||||
((wuffs_base__pixel_format)0x22040008)
|
||||
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__BGR ((wuffs_base__pixel_format)0x20000888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__BGRX ((wuffs_base__pixel_format)0x21008888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__BGRX_INDEXED \
|
||||
((wuffs_base__pixel_format)0x21088888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL \
|
||||
((wuffs_base__pixel_format)0x22008888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_INDEXED \
|
||||
((wuffs_base__pixel_format)0x22088888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL \
|
||||
((wuffs_base__pixel_format)0x23008888)
|
||||
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__RGB ((wuffs_base__pixel_format)0x30000888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__RGBX ((wuffs_base__pixel_format)0x31008888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__RGBX_INDEXED \
|
||||
((wuffs_base__pixel_format)0x31088888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL \
|
||||
((wuffs_base__pixel_format)0x32008888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL_INDEXED \
|
||||
((wuffs_base__pixel_format)0x32088888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL \
|
||||
((wuffs_base__pixel_format)0x33008888)
|
||||
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40200888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41308888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__YUV ((wuffs_base__pixel_format)0x40020888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__YUVK ((wuffs_base__pixel_format)0x41038888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__YUVA_NONPREMUL \
|
||||
((wuffs_base__pixel_format)0x42308888)
|
||||
((wuffs_base__pixel_format)0x42038888)
|
||||
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50200888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51308888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__CMY ((wuffs_base__pixel_format)0x50020888)
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__CMYK ((wuffs_base__pixel_format)0x51038888)
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) {
|
||||
@@ -1292,15 +1313,18 @@ wuffs_base__pixel_format__is_valid(wuffs_base__pixel_format f) {
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__pixel_format__is_indexed(wuffs_base__pixel_format f) {
|
||||
return ((f >> 16) & 0x0F) != 0;
|
||||
return (f >> 18) & 0x01;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) {
|
||||
return f ? (((f >> 16) & 0x03) + 1) : 0;
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) {
|
||||
return f ? (((f >> 20) & 0x03) + 1) : 0;
|
||||
}
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__INDEX_PLANE 0
|
||||
#define WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE 3
|
||||
|
||||
// --------
|
||||
|
||||
@@ -1406,7 +1430,7 @@ typedef struct {
|
||||
inline wuffs_base__rect_ie_u32 bounds();
|
||||
inline uint32_t width();
|
||||
inline uint32_t height();
|
||||
inline size_t pixbuf_size();
|
||||
inline size_t pixbuf_len();
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__pixel_config;
|
||||
@@ -1482,11 +1506,15 @@ wuffs_base__pixel_config__height(wuffs_base__pixel_config* c) {
|
||||
// decoding into a color model different from the format's intrinsic one? For
|
||||
// example, decoding a JPEG image straight to RGBA instead of to YCbCr?
|
||||
static inline size_t //
|
||||
wuffs_base__pixel_config__pixbuf_size(wuffs_base__pixel_config* c) {
|
||||
wuffs_base__pixel_config__pixbuf_len(wuffs_base__pixel_config* c) {
|
||||
if (c) {
|
||||
uint64_t wh =
|
||||
((uint64_t)c->private_impl.width) * ((uint64_t)c->private_impl.height);
|
||||
// TODO: handle things other than 1 byte per pixel.
|
||||
// TODO: handle things other than 1 byte per pixel. When doing so, consider
|
||||
// that the +1024 below could overflow.
|
||||
if (wuffs_base__pixel_format__is_indexed(c->private_impl.pixfmt)) {
|
||||
wh += 1024;
|
||||
}
|
||||
return (size_t)wh;
|
||||
}
|
||||
return 0;
|
||||
@@ -1538,8 +1566,8 @@ wuffs_base__pixel_config::height() {
|
||||
}
|
||||
|
||||
inline size_t //
|
||||
wuffs_base__pixel_config::pixbuf_size() {
|
||||
return wuffs_base__pixel_config__pixbuf_size(this);
|
||||
wuffs_base__pixel_config::pixbuf_len() {
|
||||
return wuffs_base__pixel_config__pixbuf_len(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
@@ -1552,7 +1580,8 @@ typedef struct {
|
||||
// Do not access the private_impl's fields directly. There is no API/ABI
|
||||
// compatibility or safety guarantee if you do so.
|
||||
struct {
|
||||
wuffs_base__range_ii_u64 work_buffer_size;
|
||||
wuffs_base__range_ii_u64 workbuf_len;
|
||||
uint64_t first_frame_io_position;
|
||||
uint32_t num_loops;
|
||||
bool first_frame_is_opaque;
|
||||
} private_impl;
|
||||
@@ -1562,15 +1591,17 @@ typedef struct {
|
||||
wuffs_base__pixel_subsampling pixsub,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
uint64_t work_buffer_size0,
|
||||
uint64_t work_buffer_size1,
|
||||
uint64_t workbuf_len0,
|
||||
uint64_t workbuf_len1,
|
||||
uint32_t num_loops,
|
||||
uint64_t first_frame_io_position,
|
||||
bool first_frame_is_opaque);
|
||||
inline void invalidate();
|
||||
inline bool is_valid();
|
||||
inline wuffs_base__range_ii_u64 work_buffer_size();
|
||||
inline wuffs_base__range_ii_u64 workbuf_len();
|
||||
inline uint32_t num_loops();
|
||||
inline uint32_t first_frame_is_opaque();
|
||||
inline uint64_t first_frame_io_position();
|
||||
inline bool first_frame_is_opaque();
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__image_config;
|
||||
@@ -1582,9 +1613,10 @@ wuffs_base__image_config__initialize(wuffs_base__image_config* c,
|
||||
wuffs_base__pixel_subsampling pixsub,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
uint64_t work_buffer_size0,
|
||||
uint64_t work_buffer_size1,
|
||||
uint64_t workbuf_len0,
|
||||
uint64_t workbuf_len1,
|
||||
uint32_t num_loops,
|
||||
uint64_t first_frame_io_position,
|
||||
bool first_frame_is_opaque) {
|
||||
if (!c) {
|
||||
return;
|
||||
@@ -1594,8 +1626,9 @@ wuffs_base__image_config__initialize(wuffs_base__image_config* c,
|
||||
c->pixcfg.private_impl.pixsub = pixsub;
|
||||
c->pixcfg.private_impl.width = width;
|
||||
c->pixcfg.private_impl.height = height;
|
||||
c->private_impl.work_buffer_size.min_incl = work_buffer_size0;
|
||||
c->private_impl.work_buffer_size.max_incl = work_buffer_size1;
|
||||
c->private_impl.workbuf_len.min_incl = workbuf_len0;
|
||||
c->private_impl.workbuf_len.max_incl = workbuf_len1;
|
||||
c->private_impl.first_frame_io_position = first_frame_io_position;
|
||||
c->private_impl.num_loops = num_loops;
|
||||
c->private_impl.first_frame_is_opaque = first_frame_is_opaque;
|
||||
return;
|
||||
@@ -1616,8 +1649,8 @@ wuffs_base__image_config__is_valid(wuffs_base__image_config* c) {
|
||||
}
|
||||
|
||||
static inline wuffs_base__range_ii_u64 //
|
||||
wuffs_base__image_config__work_buffer_size(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.work_buffer_size : ((wuffs_base__range_ii_u64){});
|
||||
wuffs_base__image_config__workbuf_len(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.workbuf_len : ((wuffs_base__range_ii_u64){});
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
@@ -1625,7 +1658,12 @@ wuffs_base__image_config__num_loops(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.num_loops : 0;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
static inline uint64_t //
|
||||
wuffs_base__image_config__first_frame_io_position(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.first_frame_io_position : 0;
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.first_frame_is_opaque : false;
|
||||
}
|
||||
@@ -1637,13 +1675,14 @@ wuffs_base__image_config::initialize(wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__pixel_subsampling pixsub,
|
||||
uint32_t width,
|
||||
uint32_t height,
|
||||
uint64_t work_buffer_size0,
|
||||
uint64_t work_buffer_size1,
|
||||
uint64_t workbuf_len0,
|
||||
uint64_t workbuf_len1,
|
||||
uint32_t num_loops,
|
||||
uint64_t first_frame_io_position,
|
||||
bool first_frame_is_opaque) {
|
||||
wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height,
|
||||
work_buffer_size0, work_buffer_size1,
|
||||
num_loops, first_frame_is_opaque);
|
||||
wuffs_base__image_config__initialize(
|
||||
this, pixfmt, pixsub, width, height, workbuf_len0, workbuf_len1,
|
||||
num_loops, first_frame_io_position, first_frame_is_opaque);
|
||||
}
|
||||
|
||||
inline void //
|
||||
@@ -1657,8 +1696,8 @@ wuffs_base__image_config::is_valid() {
|
||||
}
|
||||
|
||||
inline wuffs_base__range_ii_u64 //
|
||||
wuffs_base__image_config::work_buffer_size() {
|
||||
return wuffs_base__image_config__work_buffer_size(this);
|
||||
wuffs_base__image_config::workbuf_len() {
|
||||
return wuffs_base__image_config__workbuf_len(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
@@ -1666,7 +1705,12 @@ wuffs_base__image_config::num_loops() {
|
||||
return wuffs_base__image_config__num_loops(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
inline uint64_t //
|
||||
wuffs_base__image_config::first_frame_io_position() {
|
||||
return wuffs_base__image_config__first_frame_io_position(this);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
wuffs_base__image_config::first_frame_is_opaque() {
|
||||
return wuffs_base__image_config__first_frame_is_opaque(this);
|
||||
}
|
||||
@@ -1878,16 +1922,14 @@ typedef struct {
|
||||
// compatibility or safety guarantee if you do so.
|
||||
struct {
|
||||
wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];
|
||||
uint8_t palette[1024];
|
||||
// TODO: color spaces.
|
||||
} private_impl;
|
||||
|
||||
#ifdef __cplusplus
|
||||
inline wuffs_base__status set_from_slice(wuffs_base__pixel_config* pixcfg,
|
||||
wuffs_base__slice_u8 pixbuf_memory);
|
||||
inline void set_palette(wuffs_base__slice_u8 palette);
|
||||
inline wuffs_base__table_u8 plane(uint32_t p);
|
||||
inline wuffs_base__slice_u8 palette();
|
||||
inline wuffs_base__table_u8 plane(uint32_t p);
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__pixel_buffer;
|
||||
@@ -1903,28 +1945,58 @@ wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
|
||||
if (!pixcfg) {
|
||||
return wuffs_base__error__bad_argument;
|
||||
}
|
||||
|
||||
uint8_t* ptr = pixbuf_memory.ptr;
|
||||
size_t len = pixbuf_memory.len;
|
||||
if (wuffs_base__pixel_format__is_indexed(pixcfg->private_impl.pixfmt)) {
|
||||
// Split a 1024 byte chunk (256 palette entries × 4 bytes per entry) from
|
||||
// the start of pixbuf_memory. We split from the start, not the end, so
|
||||
// that the remaining ptr has the same alignment as the original ptr, up to
|
||||
// an alignment of 1024.
|
||||
if (len < 1024) {
|
||||
return wuffs_base__error__bad_argument_length_too_short;
|
||||
}
|
||||
wuffs_base__table_u8* tab =
|
||||
&b->private_impl.planes[WUFFS_BASE__PIXEL_FORMAT__INDEXED__COLOR_PLANE];
|
||||
tab->ptr = ptr;
|
||||
tab->width = 1024;
|
||||
tab->height = 1;
|
||||
tab->stride = 1024;
|
||||
ptr += 1024;
|
||||
len -= 1024;
|
||||
}
|
||||
|
||||
// TODO: don't assume 1 byte per pixel. Don't assume packed.
|
||||
uint64_t wh = ((uint64_t)pixcfg->private_impl.width) *
|
||||
((uint64_t)pixcfg->private_impl.height);
|
||||
if (wh > pixbuf_memory.len) {
|
||||
if (wh > len) {
|
||||
return wuffs_base__error__bad_argument_length_too_short;
|
||||
}
|
||||
b->pixcfg = *pixcfg;
|
||||
wuffs_base__table_u8* tab = &b->private_impl.planes[0];
|
||||
tab->ptr = pixbuf_memory.ptr;
|
||||
tab->ptr = ptr;
|
||||
tab->width = pixcfg->private_impl.width;
|
||||
tab->height = pixcfg->private_impl.height;
|
||||
tab->stride = pixcfg->private_impl.width;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// The palette argument is ignored unless its length is exactly 1024.
|
||||
static inline void //
|
||||
wuffs_base__pixel_buffer__set_palette(wuffs_base__pixel_buffer* b,
|
||||
wuffs_base__slice_u8 palette) {
|
||||
if (b && palette.ptr && (palette.len == 1024)) {
|
||||
memmove(b->private_impl.palette, palette.ptr, 1024);
|
||||
// wuffs_base__pixel_buffer__palette returns the palette color data. If
|
||||
// non-empty, it will have length 1024.
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {
|
||||
if (b &&
|
||||
wuffs_base__pixel_format__is_indexed(b->pixcfg.private_impl.pixfmt)) {
|
||||
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__slice_u8){});
|
||||
}
|
||||
|
||||
static inline wuffs_base__table_u8 //
|
||||
@@ -1934,15 +2006,6 @@ wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* b, uint32_t p) {
|
||||
: ((wuffs_base__table_u8){});
|
||||
}
|
||||
|
||||
// wuffs_base__pixel_buffer__palette returns the palette that the pixel data
|
||||
// can index. The backing array is inside b and has length 1024.
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__pixel_buffer__palette(wuffs_base__pixel_buffer* b) {
|
||||
return b ? ((wuffs_base__slice_u8){.ptr = b->private_impl.palette,
|
||||
.len = 1024})
|
||||
: ((wuffs_base__slice_u8){});
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline wuffs_base__status //
|
||||
@@ -1951,9 +2014,9 @@ wuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,
|
||||
return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);
|
||||
}
|
||||
|
||||
inline void //
|
||||
wuffs_base__pixel_buffer::set_palette(wuffs_base__slice_u8 palette) {
|
||||
wuffs_base__pixel_buffer__set_palette(this, palette);
|
||||
inline wuffs_base__slice_u8 //
|
||||
wuffs_base__pixel_buffer::palette() {
|
||||
return wuffs_base__pixel_buffer__palette(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__table_u8 //
|
||||
@@ -1961,11 +2024,6 @@ wuffs_base__pixel_buffer::plane(uint32_t p) {
|
||||
return wuffs_base__pixel_buffer__plane(this, p);
|
||||
}
|
||||
|
||||
inline wuffs_base__slice_u8 //
|
||||
wuffs_base__pixel_buffer::palette() {
|
||||
return wuffs_base__pixel_buffer__palette(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
// --------
|
||||
@@ -2558,7 +2616,7 @@ typedef struct {
|
||||
wuffs_base__io_reader a_src);
|
||||
inline uint64_t num_decoded_frame_configs();
|
||||
inline uint64_t num_decoded_frames();
|
||||
inline wuffs_base__range_ii_u64 work_buffer_size();
|
||||
inline wuffs_base__range_ii_u64 workbuf_len();
|
||||
inline wuffs_base__status restart_frame(uint64_t a_index,
|
||||
uint64_t a_io_position);
|
||||
inline wuffs_base__status decode_frame_config(wuffs_base__frame_config* a_dst,
|
||||
@@ -2566,7 +2624,7 @@ typedef struct {
|
||||
inline wuffs_base__status decode_frame(
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src,
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts);
|
||||
#endif // __cplusplus
|
||||
|
||||
@@ -2598,7 +2656,7 @@ WUFFS_BASE__MAYBE_STATIC uint64_t //
|
||||
wuffs_gif__decoder__num_decoded_frames(wuffs_gif__decoder* self);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self);
|
||||
wuffs_gif__decoder__workbuf_len(wuffs_gif__decoder* self);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__restart_frame(wuffs_gif__decoder* self,
|
||||
@@ -2614,7 +2672,7 @@ WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src,
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts);
|
||||
|
||||
// ---------------- C++ Convenience Methods
|
||||
@@ -2645,8 +2703,8 @@ wuffs_gif__decoder::num_decoded_frames() {
|
||||
}
|
||||
|
||||
inline wuffs_base__range_ii_u64 //
|
||||
wuffs_gif__decoder::work_buffer_size() {
|
||||
return wuffs_gif__decoder__work_buffer_size(this);
|
||||
wuffs_gif__decoder::workbuf_len() {
|
||||
return wuffs_gif__decoder__workbuf_len(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
@@ -2663,9 +2721,9 @@ wuffs_gif__decoder::decode_frame_config(wuffs_base__frame_config* a_dst,
|
||||
inline wuffs_base__status //
|
||||
wuffs_gif__decoder::decode_frame(wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src,
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
return wuffs_gif__decoder__decode_frame(this, a_dst, a_src, a_work_buffer,
|
||||
return wuffs_gif__decoder__decode_frame(this, a_dst, a_src, a_workbuf,
|
||||
a_opts);
|
||||
}
|
||||
|
||||
@@ -3655,8 +3713,7 @@ const char* wuffs_base__error__bad_receiver = "?base: bad receiver";
|
||||
const char* wuffs_base__error__bad_restart = "?base: bad restart";
|
||||
const char* wuffs_base__error__bad_sizeof_receiver =
|
||||
"?base: bad sizeof receiver";
|
||||
const char* wuffs_base__error__bad_work_buffer_length =
|
||||
"?base: bad work buffer length";
|
||||
const char* wuffs_base__error__bad_workbuf_length = "?base: bad workbuf length";
|
||||
const char* wuffs_base__error__bad_wuffs_version = "?base: bad wuffs version";
|
||||
const char* wuffs_base__error__cannot_return_a_suspension =
|
||||
"?base: cannot return a suspension";
|
||||
@@ -4560,22 +4617,28 @@ wuffs_deflate__decoder__decode(wuffs_deflate__decoder* self,
|
||||
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_impl.f_history,
|
||||
.len = 32768}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 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_impl.f_history,
|
||||
.len = 32768}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 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_impl.f_history,
|
||||
.len = 32768}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
v_written);
|
||||
self->private_impl.f_history_index =
|
||||
(((uint32_t)((v_n_copied & 32767))) + 32768);
|
||||
@@ -5775,8 +5838,10 @@ 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_impl.f_history,
|
||||
.len = 32768}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
(v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
goto label_1_break;
|
||||
@@ -5784,8 +5849,10 @@ 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_impl.f_history,
|
||||
.len = 32768}));
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 32768,
|
||||
}));
|
||||
goto label_1_break;
|
||||
}
|
||||
label_1_break:;
|
||||
@@ -6160,8 +6227,10 @@ 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_impl.f_history,
|
||||
.len = 32768}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
(v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
@@ -6184,7 +6253,9 @@ wuffs_deflate__decoder__decode_huffman_slow(wuffs_deflate__decoder* self,
|
||||
&iop_a_dst, io1_a_dst, v_hlen,
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_history, .len = 32768}),
|
||||
.ptr = self->private_impl.f_history,
|
||||
.len = 32768,
|
||||
}),
|
||||
(v_hdist & 32767)));
|
||||
if (v_hlen <= v_n_copied) {
|
||||
v_hlen = 0;
|
||||
@@ -6441,9 +6512,10 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self,
|
||||
(self->private_impl.f_frame_rect_y1 == self->private_impl.f_height));
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__initialize(
|
||||
a_dst, 570984584, 0, self->private_impl.f_width,
|
||||
a_dst, 570687496, 0, self->private_impl.f_width,
|
||||
self->private_impl.f_height, ((uint64_t)(self->private_impl.f_width)),
|
||||
((uint64_t)(self->private_impl.f_width)), v_num_loops, v_ffio);
|
||||
((uint64_t)(self->private_impl.f_width)), v_num_loops,
|
||||
self->private_impl.f_frame_config_io_position, v_ffio);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 1;
|
||||
|
||||
@@ -6495,10 +6567,10 @@ wuffs_gif__decoder__num_decoded_frames(wuffs_gif__decoder* self) {
|
||||
return self->private_impl.f_num_decoded_frames_value;
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.work_buffer_size
|
||||
// -------- func gif.decoder.workbuf_len
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self) {
|
||||
wuffs_gif__decoder__workbuf_len(wuffs_gif__decoder* self) {
|
||||
if (!self) {
|
||||
return ((wuffs_base__range_ii_u64){});
|
||||
}
|
||||
@@ -6605,10 +6677,15 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
|
||||
wuffs_base__frame_config__update(
|
||||
a_dst,
|
||||
wuffs_base__utility__make_rect_ie_u32(
|
||||
&self->private_impl.f_util, self->private_impl.f_frame_rect_x0,
|
||||
self->private_impl.f_frame_rect_y0,
|
||||
self->private_impl.f_frame_rect_x1,
|
||||
self->private_impl.f_frame_rect_y1),
|
||||
&self->private_impl.f_util,
|
||||
wuffs_base__u32__min(self->private_impl.f_frame_rect_x0,
|
||||
self->private_impl.f_width),
|
||||
wuffs_base__u32__min(self->private_impl.f_frame_rect_y0,
|
||||
self->private_impl.f_height),
|
||||
wuffs_base__u32__min(self->private_impl.f_frame_rect_x1,
|
||||
self->private_impl.f_width),
|
||||
wuffs_base__u32__min(self->private_impl.f_frame_rect_y1,
|
||||
self->private_impl.f_height)),
|
||||
self->private_impl.f_gc_duration,
|
||||
self->private_impl.f_num_decoded_frame_configs_value,
|
||||
self->private_impl.f_frame_config_io_position, v_blend,
|
||||
@@ -6746,7 +6823,7 @@ WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src,
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
if (!self) {
|
||||
return wuffs_base__error__bad_receiver;
|
||||
@@ -6770,9 +6847,9 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (((uint64_t)(a_work_buffer.len)) !=
|
||||
if (((uint64_t)(a_workbuf.len)) !=
|
||||
((uint64_t)(self->private_impl.f_width))) {
|
||||
status = wuffs_base__error__bad_work_buffer_length;
|
||||
status = wuffs_base__error__bad_workbuf_length;
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_call_sequence != 2) {
|
||||
@@ -8050,10 +8127,14 @@ 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_impl.f_palettes[1],
|
||||
.len = 1024}),
|
||||
((wuffs_base__slice_u8){.ptr = self->private_impl.f_palettes[0],
|
||||
.len = 1024}));
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_palettes[1],
|
||||
.len = 1024,
|
||||
}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_palettes[0],
|
||||
.len = 1024,
|
||||
}));
|
||||
} else {
|
||||
self->private_impl.f_which_palette = 0;
|
||||
}
|
||||
@@ -8071,11 +8152,13 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
(4 * ((uint32_t)(self->private_impl.f_gc_transparent_index))) + 3)] =
|
||||
0;
|
||||
}
|
||||
wuffs_base__pixel_buffer__set_palette(
|
||||
a_dst, ((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl
|
||||
.f_palettes[self->private_impl.f_which_palette],
|
||||
.len = 1024}));
|
||||
wuffs_base__slice_u8__copy_from_slice(
|
||||
wuffs_base__pixel_buffer__palette(a_dst),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl
|
||||
.f_palettes[self->private_impl.f_which_palette],
|
||||
.len = 1024,
|
||||
}));
|
||||
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
|
||||
(memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})),
|
||||
wuffs_base__ignore_check_wuffs_version_status(
|
||||
@@ -8126,7 +8209,9 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
&v_w, &u_w, &iop_v_w, &io1_v_w,
|
||||
wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_uncompressed, .len = 4096}),
|
||||
.ptr = self->private_impl.f_uncompressed,
|
||||
.len = 4096,
|
||||
}),
|
||||
self->private_impl.f_uncompressed_wi));
|
||||
wuffs_base__io_reader__set_limit(&a_src, iop_a_src, v_block_size);
|
||||
wuffs_base__io_reader__set_mark(&a_src, iop_a_src);
|
||||
@@ -8242,8 +8327,10 @@ label_0_continue:;
|
||||
while (self->private_impl.f_uncompressed_wi >
|
||||
self->private_impl.f_uncompressed_ri) {
|
||||
v_src = wuffs_base__slice_u8__subslice_ij(
|
||||
((wuffs_base__slice_u8){.ptr = self->private_impl.f_uncompressed,
|
||||
.len = 4096}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_uncompressed,
|
||||
.len = 4096,
|
||||
}),
|
||||
self->private_impl.f_uncompressed_ri,
|
||||
self->private_impl.f_uncompressed_wi);
|
||||
if (self->private_impl.f_dst_y >= self->private_impl.f_frame_rect_y1) {
|
||||
@@ -8994,8 +9081,10 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self,
|
||||
}
|
||||
while (true) {
|
||||
v_expansion = wuffs_base__slice_u8__subslice_i(
|
||||
((wuffs_base__slice_u8){.ptr = self->private_impl.f_stack,
|
||||
.len = 4096}),
|
||||
((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_stack,
|
||||
.len = 4096,
|
||||
}),
|
||||
v_s);
|
||||
v_n_copied = wuffs_base__io_writer__copy_from_slice(
|
||||
&iop_a_dst, io1_a_dst, v_expansion);
|
||||
|
||||
Reference in new issue
Block a user