mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
wuffs gen -version=0.2.0-alpha.8
This commit is contained in:
1 parent
9514b12c7f
commit
e3e94476ab
1 file changed
+649
-278
+649
-278
@@ -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-07-15 UTC,
|
||||
// based on revision dcda30b96a9239910d7f50e937518d81cf75dc1c.
|
||||
// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-07-21 UTC,
|
||||
// based on revision 9514b12c7f0a36a4bbab178d0d5fcb1b87a34011.
|
||||
#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.7"
|
||||
#define WUFFS_VERSION_STRING "0.2.0-alpha.7"
|
||||
#define WUFFS_VERSION_EXTENSION "alpha.8"
|
||||
#define WUFFS_VERSION_STRING "0.2.0-alpha.8"
|
||||
|
||||
// Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have
|
||||
// static storage. The motivation is discussed in the "ALLOW STATIC
|
||||
@@ -1093,6 +1093,28 @@ wuffs_base__io_buffer__struct::writer() {
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
// Copyright 2017 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ---------------- Images
|
||||
|
||||
// wuffs_base__color_u32argb is an 8 bit per channel Alpha, Red, Green, Blue
|
||||
@@ -1270,10 +1292,6 @@ wuffs_base__pixel_format__num_planes(wuffs_base__pixel_format f) {
|
||||
return f ? (((f >> 20) & 0x03) + 1) : 0;
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
wuffs_base__table_u8 planes[WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX];
|
||||
} wuffs_base__pixel_buffer;
|
||||
|
||||
// --------
|
||||
|
||||
// wuffs_base__pixel_subsampling encodes the mapping of pixel space coordinates
|
||||
@@ -1364,6 +1382,165 @@ typedef struct {
|
||||
wuffs_base__pixel_subsampling pixsub;
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
} private_impl;
|
||||
|
||||
#ifdef __cplusplus
|
||||
inline void initialize(wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__pixel_subsampling pixsub,
|
||||
uint32_t width,
|
||||
uint32_t height);
|
||||
inline void invalidate();
|
||||
inline bool is_valid();
|
||||
inline wuffs_base__pixel_format pixel_format();
|
||||
inline wuffs_base__pixel_subsampling pixel_subsampling();
|
||||
inline wuffs_base__rect_ie_u32 bounds();
|
||||
inline uint32_t width();
|
||||
inline uint32_t height();
|
||||
inline size_t pixbuf_size();
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__pixel_config;
|
||||
|
||||
// TODO: Should this function return bool? An error type?
|
||||
static inline void //
|
||||
wuffs_base__pixel_config__initialize(wuffs_base__pixel_config* c,
|
||||
wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__pixel_subsampling pixsub,
|
||||
uint32_t width,
|
||||
uint32_t height) {
|
||||
if (!c) {
|
||||
return;
|
||||
}
|
||||
if (pixfmt) {
|
||||
uint64_t wh = ((uint64_t)width) * ((uint64_t)height);
|
||||
// TODO: handle things other than 1 byte per pixel.
|
||||
if (wh <= ((uint64_t)SIZE_MAX)) {
|
||||
c->private_impl.pixfmt = pixfmt;
|
||||
c->private_impl.pixsub = pixsub;
|
||||
c->private_impl.width = width;
|
||||
c->private_impl.height = height;
|
||||
return;
|
||||
}
|
||||
}
|
||||
*c = ((wuffs_base__pixel_config){});
|
||||
}
|
||||
|
||||
static inline void //
|
||||
wuffs_base__pixel_config__invalidate(wuffs_base__pixel_config* c) {
|
||||
if (c) {
|
||||
*c = ((wuffs_base__pixel_config){});
|
||||
}
|
||||
}
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__pixel_config__is_valid(wuffs_base__pixel_config* c) {
|
||||
return c && c->private_impl.pixfmt;
|
||||
}
|
||||
|
||||
static inline wuffs_base__pixel_format //
|
||||
wuffs_base__pixel_config__pixel_format(wuffs_base__pixel_config* c) {
|
||||
return c ? c->private_impl.pixfmt : 0;
|
||||
}
|
||||
|
||||
static inline wuffs_base__pixel_subsampling //
|
||||
wuffs_base__pixel_config__pixel_subsampling(wuffs_base__pixel_config* c) {
|
||||
return c ? c->private_impl.pixsub : 0;
|
||||
}
|
||||
|
||||
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){});
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__pixel_config__width(wuffs_base__pixel_config* c) {
|
||||
return c ? c->private_impl.width : 0;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__pixel_config__height(wuffs_base__pixel_config* c) {
|
||||
return c ? c->private_impl.height : 0;
|
||||
}
|
||||
|
||||
// TODO: this is the right API for planar (not packed) pixbufs? Should it allow
|
||||
// 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) {
|
||||
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.
|
||||
return (size_t)wh;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline void //
|
||||
wuffs_base__pixel_config::initialize(wuffs_base__pixel_format pixfmt,
|
||||
wuffs_base__pixel_subsampling pixsub,
|
||||
uint32_t width,
|
||||
uint32_t height) {
|
||||
wuffs_base__pixel_config__initialize(this, pixfmt, pixsub, width, height);
|
||||
}
|
||||
|
||||
inline void //
|
||||
wuffs_base__pixel_config::invalidate() {
|
||||
wuffs_base__pixel_config__invalidate(this);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
wuffs_base__pixel_config::is_valid() {
|
||||
return wuffs_base__pixel_config__is_valid(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__pixel_format //
|
||||
wuffs_base__pixel_config::pixel_format() {
|
||||
return wuffs_base__pixel_config__pixel_format(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__pixel_subsampling //
|
||||
wuffs_base__pixel_config::pixel_subsampling() {
|
||||
return wuffs_base__pixel_config__pixel_subsampling(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__pixel_config::bounds() {
|
||||
return wuffs_base__pixel_config__bounds(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__pixel_config::width() {
|
||||
return wuffs_base__pixel_config__width(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__pixel_config::height() {
|
||||
return wuffs_base__pixel_config__height(this);
|
||||
}
|
||||
|
||||
inline size_t //
|
||||
wuffs_base__pixel_config::pixbuf_size() {
|
||||
return wuffs_base__pixel_config__pixbuf_size(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
// --------
|
||||
|
||||
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__pixel_config pixcfg;
|
||||
uint32_t num_loops;
|
||||
bool first_frame_is_opaque;
|
||||
} private_impl;
|
||||
@@ -1377,6 +1554,7 @@ typedef struct {
|
||||
bool first_frame_is_opaque);
|
||||
inline void invalidate();
|
||||
inline bool is_valid();
|
||||
inline wuffs_base__pixel_config* pixel_config();
|
||||
inline wuffs_base__pixel_format pixel_format();
|
||||
inline wuffs_base__pixel_subsampling pixel_subsampling();
|
||||
inline wuffs_base__rect_ie_u32 bounds();
|
||||
@@ -1384,7 +1562,6 @@ typedef struct {
|
||||
inline uint32_t height();
|
||||
inline uint32_t num_loops();
|
||||
inline uint32_t first_frame_is_opaque();
|
||||
inline size_t pixbuf_size();
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__image_config;
|
||||
@@ -1401,18 +1578,14 @@ wuffs_base__image_config__initialize(wuffs_base__image_config* c,
|
||||
if (!c) {
|
||||
return;
|
||||
}
|
||||
if (pixfmt) {
|
||||
uint64_t wh = ((uint64_t)width) * ((uint64_t)height);
|
||||
// TODO: handle things other than 1 byte per pixel.
|
||||
if (wh <= ((uint64_t)SIZE_MAX)) {
|
||||
c->private_impl.pixfmt = pixfmt;
|
||||
c->private_impl.pixsub = pixsub;
|
||||
c->private_impl.width = width;
|
||||
c->private_impl.height = height;
|
||||
c->private_impl.num_loops = num_loops;
|
||||
c->private_impl.first_frame_is_opaque = first_frame_is_opaque;
|
||||
return;
|
||||
}
|
||||
if (wuffs_base__pixel_format__is_valid(pixfmt)) {
|
||||
c->private_impl.pixcfg.private_impl.pixfmt = pixfmt;
|
||||
c->private_impl.pixcfg.private_impl.pixsub = pixsub;
|
||||
c->private_impl.pixcfg.private_impl.width = width;
|
||||
c->private_impl.pixcfg.private_impl.height = height;
|
||||
c->private_impl.num_loops = num_loops;
|
||||
c->private_impl.first_frame_is_opaque = first_frame_is_opaque;
|
||||
return;
|
||||
}
|
||||
*c = ((wuffs_base__image_config){});
|
||||
}
|
||||
@@ -1426,17 +1599,22 @@ wuffs_base__image_config__invalidate(wuffs_base__image_config* c) {
|
||||
|
||||
static inline bool //
|
||||
wuffs_base__image_config__is_valid(wuffs_base__image_config* c) {
|
||||
return c && c->private_impl.pixfmt;
|
||||
return c && wuffs_base__pixel_config__is_valid(&(c->private_impl.pixcfg));
|
||||
}
|
||||
|
||||
static inline wuffs_base__pixel_config* //
|
||||
wuffs_base__image_config__pixel_config(wuffs_base__image_config* c) {
|
||||
return c ? &c->private_impl.pixcfg : NULL;
|
||||
}
|
||||
|
||||
static inline wuffs_base__pixel_format //
|
||||
wuffs_base__image_config__pixel_format(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.pixfmt : 0;
|
||||
return c ? c->private_impl.pixcfg.private_impl.pixfmt : 0;
|
||||
}
|
||||
|
||||
static inline wuffs_base__pixel_subsampling //
|
||||
wuffs_base__image_config__pixel_subsampling(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.pixsub : 0;
|
||||
return c ? c->private_impl.pixcfg.private_impl.pixsub : 0;
|
||||
}
|
||||
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
@@ -1444,20 +1622,20 @@ wuffs_base__image_config__bounds(wuffs_base__image_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,
|
||||
.max_excl_x = c->private_impl.pixcfg.private_impl.width,
|
||||
.max_excl_y = c->private_impl.pixcfg.private_impl.height,
|
||||
})
|
||||
: ((wuffs_base__rect_ie_u32){});
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__image_config__width(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.width : 0;
|
||||
return c ? c->private_impl.pixcfg.private_impl.width : 0;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__image_config__height(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.height : 0;
|
||||
return c ? c->private_impl.pixcfg.private_impl.height : 0;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
@@ -1470,20 +1648,6 @@ wuffs_base__image_config__first_frame_is_opaque(wuffs_base__image_config* c) {
|
||||
return c ? c->private_impl.first_frame_is_opaque : false;
|
||||
}
|
||||
|
||||
// TODO: this is the right API for planar (not packed) pixbufs? Should it allow
|
||||
// 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__image_config__pixbuf_size(wuffs_base__image_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.
|
||||
return (size_t)wh;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline void //
|
||||
@@ -1507,6 +1671,11 @@ wuffs_base__image_config::is_valid() {
|
||||
return wuffs_base__image_config__is_valid(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__pixel_config* //
|
||||
wuffs_base__image_config::pixel_config() {
|
||||
return wuffs_base__image_config__pixel_config(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__pixel_format //
|
||||
wuffs_base__image_config::pixel_format() {
|
||||
return wuffs_base__image_config__pixel_format(this);
|
||||
@@ -1542,11 +1711,6 @@ wuffs_base__image_config::first_frame_is_opaque() {
|
||||
return wuffs_base__image_config__first_frame_is_opaque(this);
|
||||
}
|
||||
|
||||
inline size_t //
|
||||
wuffs_base__image_config::pixbuf_size() {
|
||||
return wuffs_base__image_config__pixbuf_size(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
// --------
|
||||
@@ -1573,260 +1737,284 @@ 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__image_config config;
|
||||
wuffs_base__pixel_buffer pixbuf;
|
||||
// TODO: color spaces.
|
||||
wuffs_base__rect_ie_u32 dirty_rect;
|
||||
wuffs_base__rect_ie_u32 bounds;
|
||||
wuffs_base__flicks duration;
|
||||
bool blend;
|
||||
wuffs_base__animation_disposal disposal;
|
||||
bool palette_changed;
|
||||
uint8_t palette[1024];
|
||||
} private_impl;
|
||||
|
||||
#ifdef __cplusplus
|
||||
inline wuffs_base__status set_from_pixbuf(wuffs_base__image_config config,
|
||||
wuffs_base__pixel_buffer pixbuf);
|
||||
inline wuffs_base__status set_from_slice(wuffs_base__image_config config,
|
||||
wuffs_base__slice_u8 pixbuf_memory);
|
||||
inline void update(wuffs_base__rect_ie_u32 dirty_rect,
|
||||
inline void update(wuffs_base__rect_ie_u32 bounds,
|
||||
wuffs_base__flicks duration,
|
||||
bool blend,
|
||||
wuffs_base__animation_disposal disposal,
|
||||
wuffs_base__slice_u8 palette);
|
||||
inline wuffs_base__image_config* image_config();
|
||||
bool palette_changed);
|
||||
inline wuffs_base__rect_ie_u32 bounds();
|
||||
inline uint32_t width();
|
||||
inline uint32_t height();
|
||||
inline wuffs_base__rect_ie_u32 dirty_rect();
|
||||
inline wuffs_base__flicks duration();
|
||||
inline bool blend();
|
||||
inline wuffs_base__animation_disposal disposal();
|
||||
inline bool palette_changed();
|
||||
inline wuffs_base__slice_u8 palette();
|
||||
inline wuffs_base__table_u8 plane(uint32_t p);
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__image_buffer;
|
||||
} wuffs_base__frame_config;
|
||||
|
||||
static inline wuffs_base__status //
|
||||
wuffs_base__image_buffer__set_from_pixbuf(wuffs_base__image_buffer* b,
|
||||
wuffs_base__image_config config,
|
||||
wuffs_base__pixel_buffer pixbuf) {
|
||||
if (!b) {
|
||||
return WUFFS_BASE__ERROR_BAD_RECEIVER;
|
||||
}
|
||||
*b = ((wuffs_base__image_buffer){});
|
||||
b->private_impl.config = config;
|
||||
b->private_impl.pixbuf = pixbuf;
|
||||
return WUFFS_BASE__STATUS_OK;
|
||||
}
|
||||
|
||||
static inline wuffs_base__status //
|
||||
wuffs_base__image_buffer__set_from_slice(wuffs_base__image_buffer* b,
|
||||
wuffs_base__image_config config,
|
||||
wuffs_base__slice_u8 pixbuf_memory) {
|
||||
if (!b) {
|
||||
return WUFFS_BASE__ERROR_BAD_RECEIVER;
|
||||
}
|
||||
*b = ((wuffs_base__image_buffer){});
|
||||
// TODO: don't assume 1 byte per pixel. Don't assume packed.
|
||||
uint64_t wh = ((uint64_t)config.private_impl.width) *
|
||||
((uint64_t)config.private_impl.height);
|
||||
if (wh > pixbuf_memory.len) {
|
||||
return WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT;
|
||||
}
|
||||
b->private_impl.config = config;
|
||||
wuffs_base__table_u8* tab = &b->private_impl.pixbuf.planes[0];
|
||||
tab->ptr = pixbuf_memory.ptr;
|
||||
tab->width = config.private_impl.width;
|
||||
tab->height = config.private_impl.height;
|
||||
tab->stride = config.private_impl.width;
|
||||
return WUFFS_BASE__STATUS_OK;
|
||||
}
|
||||
|
||||
// The palette argument is ignored unless its length is exactly 1024.
|
||||
static inline void //
|
||||
wuffs_base__image_buffer__update(wuffs_base__image_buffer* b,
|
||||
wuffs_base__rect_ie_u32 dirty_rect,
|
||||
wuffs_base__frame_config__update(wuffs_base__frame_config* c,
|
||||
wuffs_base__rect_ie_u32 bounds,
|
||||
wuffs_base__flicks duration,
|
||||
bool blend,
|
||||
wuffs_base__animation_disposal disposal,
|
||||
wuffs_base__slice_u8 palette) {
|
||||
if (!b) {
|
||||
bool palette_changed) {
|
||||
if (!c) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Clip the dirty_rect to the image bounds.
|
||||
dirty_rect.max_excl_x = wuffs_base__u32__min(
|
||||
dirty_rect.max_excl_x, b->private_impl.config.private_impl.width);
|
||||
dirty_rect.max_excl_y = wuffs_base__u32__min(
|
||||
dirty_rect.max_excl_y, b->private_impl.config.private_impl.height);
|
||||
b->private_impl.dirty_rect = dirty_rect;
|
||||
|
||||
b->private_impl.duration = duration;
|
||||
b->private_impl.blend = blend;
|
||||
b->private_impl.disposal = disposal;
|
||||
b->private_impl.palette_changed = palette.ptr && (palette.len == 1024);
|
||||
if (b->private_impl.palette_changed) {
|
||||
memmove(b->private_impl.palette, palette.ptr, 1024);
|
||||
}
|
||||
}
|
||||
|
||||
// wuffs_base__image_config returns the overall configuration for this frame.
|
||||
static inline wuffs_base__image_config* //
|
||||
wuffs_base__image_buffer__image_config(wuffs_base__image_buffer* b) {
|
||||
return b ? &b->private_impl.config : NULL;
|
||||
c->private_impl.bounds = bounds;
|
||||
c->private_impl.duration = duration;
|
||||
c->private_impl.blend = blend;
|
||||
c->private_impl.disposal = disposal;
|
||||
c->private_impl.palette_changed = palette_changed;
|
||||
}
|
||||
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__image_buffer__bounds(wuffs_base__image_buffer* b) {
|
||||
return b ? wuffs_base__image_config__bounds(&b->private_impl.config)
|
||||
: ((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){});
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__image_buffer__width(wuffs_base__image_buffer* b) {
|
||||
return b ? wuffs_base__image_config__width(&b->private_impl.config) : 0;
|
||||
wuffs_base__frame_config__width(wuffs_base__frame_config* c) {
|
||||
return c ? wuffs_base__rect_ie_u32__width(&c->private_impl.bounds) : 0;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__image_buffer__height(wuffs_base__image_buffer* b) {
|
||||
return b ? wuffs_base__image_config__height(&b->private_impl.config) : 0;
|
||||
wuffs_base__frame_config__height(wuffs_base__frame_config* c) {
|
||||
return c ? wuffs_base__rect_ie_u32__height(&c->private_impl.bounds) : 0;
|
||||
}
|
||||
|
||||
// wuffs_base__image_buffer__dirty_rect returns an upper bound for what part of
|
||||
// this frame's pixels differs from the previous frame.
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__image_buffer__dirty_rect(wuffs_base__image_buffer* b) {
|
||||
return b ? b->private_impl.dirty_rect : ((wuffs_base__rect_ie_u32){});
|
||||
}
|
||||
|
||||
// wuffs_base__image_buffer__duration returns the amount of time to display
|
||||
// wuffs_base__frame_config__duration returns the amount of time to display
|
||||
// this frame. Zero means to display forever - a still (non-animated) image.
|
||||
static inline wuffs_base__flicks //
|
||||
wuffs_base__image_buffer__duration(wuffs_base__image_buffer* b) {
|
||||
return b ? b->private_impl.duration : 0;
|
||||
wuffs_base__frame_config__duration(wuffs_base__frame_config* c) {
|
||||
return c ? c->private_impl.duration : 0;
|
||||
}
|
||||
|
||||
// wuffs_base__image_buffer__blend returns, for a transparent image, whether to
|
||||
// wuffs_base__frame_config__blend returns, for a transparent image, whether to
|
||||
// blend this frame with the existing canvas.
|
||||
//
|
||||
// In Porter-Duff compositing operator terminology, false means "src" and true
|
||||
// means "src over dst".
|
||||
static inline bool //
|
||||
wuffs_base__image_buffer__blend(wuffs_base__image_buffer* b) {
|
||||
return b && b->private_impl.blend;
|
||||
wuffs_base__frame_config__blend(wuffs_base__frame_config* c) {
|
||||
return c && c->private_impl.blend;
|
||||
}
|
||||
|
||||
// wuffs_base__image_buffer__disposal returns, for an animated image, how to
|
||||
// wuffs_base__frame_config__disposal returns, for an animated image, how to
|
||||
// dispose of this frame after displaying it.
|
||||
static inline wuffs_base__animation_disposal //
|
||||
wuffs_base__image_buffer__disposal(wuffs_base__image_buffer* b) {
|
||||
return b ? b->private_impl.disposal : 0;
|
||||
wuffs_base__frame_config__disposal(wuffs_base__frame_config* c) {
|
||||
return c ? c->private_impl.disposal : 0;
|
||||
}
|
||||
|
||||
// wuffs_base__image_buffer__palette_changed returns whether this frame's
|
||||
// wuffs_base__frame_config__palette_changed returns whether this frame's
|
||||
// palette differs from the previous frame. It is conservative and may return
|
||||
// false positives (but never false negatives).
|
||||
static inline bool //
|
||||
wuffs_base__image_buffer__palette_changed(wuffs_base__image_buffer* b) {
|
||||
return b && b->private_impl.palette_changed;
|
||||
wuffs_base__frame_config__palette_changed(wuffs_base__frame_config* c) {
|
||||
return c && c->private_impl.palette_changed;
|
||||
}
|
||||
|
||||
// wuffs_base__image_buffer__palette returns the palette that the pixel data
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline void //
|
||||
wuffs_base__frame_config::update(wuffs_base__rect_ie_u32 bounds,
|
||||
wuffs_base__flicks duration,
|
||||
bool blend,
|
||||
wuffs_base__animation_disposal disposal,
|
||||
bool palette_changed) {
|
||||
wuffs_base__frame_config__update(this, bounds, duration, blend, disposal,
|
||||
palette_changed);
|
||||
}
|
||||
|
||||
inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__frame_config::bounds() {
|
||||
return wuffs_base__frame_config__bounds(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__frame_config::width() {
|
||||
return wuffs_base__frame_config__width(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__frame_config::height() {
|
||||
return wuffs_base__frame_config__height(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__flicks //
|
||||
wuffs_base__frame_config::duration() {
|
||||
return wuffs_base__frame_config__duration(this);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
wuffs_base__frame_config::blend() {
|
||||
return wuffs_base__frame_config__blend(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__animation_disposal //
|
||||
wuffs_base__frame_config::disposal() {
|
||||
return wuffs_base__frame_config__disposal(this);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
wuffs_base__frame_config::palette_changed() {
|
||||
return wuffs_base__frame_config__palette_changed(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
// --------
|
||||
|
||||
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__pixel_config pixcfg;
|
||||
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__pixel_config* pixel_config();
|
||||
inline wuffs_base__rect_ie_u32 bounds();
|
||||
inline uint32_t width();
|
||||
inline uint32_t height();
|
||||
inline wuffs_base__table_u8 plane(uint32_t p);
|
||||
inline wuffs_base__slice_u8 palette();
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_base__pixel_buffer;
|
||||
|
||||
static inline wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_from_slice(wuffs_base__pixel_buffer* b,
|
||||
wuffs_base__pixel_config* pixcfg,
|
||||
wuffs_base__slice_u8 pixbuf_memory) {
|
||||
if (!b) {
|
||||
return WUFFS_BASE__ERROR_BAD_RECEIVER;
|
||||
}
|
||||
*b = ((wuffs_base__pixel_buffer){});
|
||||
if (!pixcfg) {
|
||||
return WUFFS_BASE__ERROR_BAD_ARGUMENT;
|
||||
}
|
||||
// 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) {
|
||||
return WUFFS_BASE__ERROR_BAD_ARGUMENT_LENGTH_TOO_SHORT;
|
||||
}
|
||||
b->private_impl.pixcfg = *pixcfg;
|
||||
wuffs_base__table_u8* tab = &b->private_impl.planes[0];
|
||||
tab->ptr = pixbuf_memory.ptr;
|
||||
tab->width = pixcfg->private_impl.width;
|
||||
tab->height = pixcfg->private_impl.height;
|
||||
tab->stride = pixcfg->private_impl.width;
|
||||
return WUFFS_BASE__STATUS_OK;
|
||||
}
|
||||
|
||||
// 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_config returns the overall configuration for this frame.
|
||||
static inline wuffs_base__pixel_config* //
|
||||
wuffs_base__pixel_buffer__pixel_config(wuffs_base__pixel_buffer* b) {
|
||||
return b ? &b->private_impl.pixcfg : NULL;
|
||||
}
|
||||
|
||||
static inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__pixel_buffer__bounds(wuffs_base__pixel_buffer* b) {
|
||||
return b ? wuffs_base__pixel_config__bounds(&b->private_impl.pixcfg)
|
||||
: ((wuffs_base__rect_ie_u32){});
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__pixel_buffer__width(wuffs_base__pixel_buffer* b) {
|
||||
return b ? wuffs_base__pixel_config__width(&b->private_impl.pixcfg) : 0;
|
||||
}
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_base__pixel_buffer__height(wuffs_base__pixel_buffer* b) {
|
||||
return b ? wuffs_base__pixel_config__height(&b->private_impl.pixcfg) : 0;
|
||||
}
|
||||
|
||||
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){});
|
||||
}
|
||||
|
||||
// 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__image_buffer__palette(wuffs_base__image_buffer* b) {
|
||||
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){});
|
||||
}
|
||||
|
||||
static inline wuffs_base__table_u8 //
|
||||
wuffs_base__image_buffer__plane(wuffs_base__image_buffer* b, uint32_t p) {
|
||||
return (b && (p < WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX))
|
||||
? b->private_impl.pixbuf.planes[p]
|
||||
: ((wuffs_base__table_u8){});
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_base__image_buffer::set_from_pixbuf(wuffs_base__image_config config,
|
||||
wuffs_base__pixel_buffer pixbuf) {
|
||||
return wuffs_base__image_buffer__set_from_pixbuf(this, config, pixbuf);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_base__image_buffer::set_from_slice(wuffs_base__image_config config,
|
||||
wuffs_base__pixel_buffer::set_from_slice(wuffs_base__pixel_config* pixcfg,
|
||||
wuffs_base__slice_u8 pixbuf_memory) {
|
||||
return wuffs_base__image_buffer__set_from_slice(this, config, pixbuf_memory);
|
||||
return wuffs_base__pixel_buffer__set_from_slice(this, pixcfg, pixbuf_memory);
|
||||
}
|
||||
|
||||
inline void //
|
||||
wuffs_base__image_buffer::update(wuffs_base__rect_ie_u32 dirty_rect,
|
||||
wuffs_base__flicks duration,
|
||||
bool blend,
|
||||
wuffs_base__animation_disposal disposal,
|
||||
wuffs_base__slice_u8 palette) {
|
||||
wuffs_base__image_buffer__update(this, dirty_rect, duration, blend, disposal,
|
||||
palette);
|
||||
wuffs_base__pixel_buffer::set_palette(wuffs_base__slice_u8 palette) {
|
||||
wuffs_base__pixel_buffer__set_palette(this, palette);
|
||||
}
|
||||
|
||||
inline wuffs_base__image_config* //
|
||||
wuffs_base__image_buffer::image_config() {
|
||||
return wuffs_base__image_buffer__image_config(this);
|
||||
inline wuffs_base__pixel_config* //
|
||||
wuffs_base__pixel_buffer::pixel_config() {
|
||||
return wuffs_base__pixel_buffer__pixel_config(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__image_buffer::bounds() {
|
||||
return wuffs_base__image_buffer__bounds(this);
|
||||
wuffs_base__pixel_buffer::bounds() {
|
||||
return wuffs_base__pixel_buffer__bounds(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__image_buffer::width() {
|
||||
return wuffs_base__image_buffer__width(this);
|
||||
wuffs_base__pixel_buffer::width() {
|
||||
return wuffs_base__pixel_buffer__width(this);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__image_buffer::height() {
|
||||
return wuffs_base__image_buffer__height(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__rect_ie_u32 //
|
||||
wuffs_base__image_buffer::dirty_rect() {
|
||||
return wuffs_base__image_buffer__dirty_rect(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__flicks //
|
||||
wuffs_base__image_buffer::duration() {
|
||||
return wuffs_base__image_buffer__duration(this);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
wuffs_base__image_buffer::blend() {
|
||||
return wuffs_base__image_buffer__blend(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__animation_disposal //
|
||||
wuffs_base__image_buffer::disposal() {
|
||||
return wuffs_base__image_buffer__disposal(this);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
wuffs_base__image_buffer::palette_changed() {
|
||||
return wuffs_base__image_buffer__palette_changed(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__slice_u8 //
|
||||
wuffs_base__image_buffer::palette() {
|
||||
return wuffs_base__image_buffer__palette(this);
|
||||
wuffs_base__pixel_buffer::height() {
|
||||
return wuffs_base__pixel_buffer__height(this);
|
||||
}
|
||||
|
||||
inline wuffs_base__table_u8 //
|
||||
wuffs_base__image_buffer::plane(uint32_t p) {
|
||||
return wuffs_base__image_buffer__plane(this, p);
|
||||
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
|
||||
@@ -2340,6 +2528,7 @@ typedef struct {
|
||||
bool f_has_full_global_palette;
|
||||
bool f_has_full_palette;
|
||||
bool f_use_local_palette;
|
||||
uint8_t f_which_palette;
|
||||
uint8_t f_interlace;
|
||||
bool f_seen_num_loops;
|
||||
uint32_t f_num_loops;
|
||||
@@ -2367,6 +2556,13 @@ typedef struct {
|
||||
uint32_t v_num_loops;
|
||||
bool v_ffio;
|
||||
} c_decode_image_config[1];
|
||||
struct {
|
||||
uint32_t coro_susp_point;
|
||||
} c_decode_frame_config[1];
|
||||
struct {
|
||||
uint32_t coro_susp_point;
|
||||
uint8_t v_lw;
|
||||
} c_skip_frame[1];
|
||||
struct {
|
||||
uint32_t coro_susp_point;
|
||||
} c_decode_frame[1];
|
||||
@@ -2433,9 +2629,13 @@ typedef struct {
|
||||
wuffs_base__io_reader a_src);
|
||||
inline uint64_t frame_count();
|
||||
inline wuffs_base__range_ii_u64 work_buffer_size();
|
||||
inline wuffs_base__status decode_frame(wuffs_base__image_buffer* a_dst,
|
||||
inline wuffs_base__status decode_frame_config(wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_reader a_src);
|
||||
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_work_buffer,
|
||||
uint32_t a_pixbuf_origin_x,
|
||||
uint32_t a_pixbuf_origin_y);
|
||||
#endif // __cplusplus
|
||||
|
||||
} wuffs_gif__decoder;
|
||||
@@ -2464,11 +2664,18 @@ wuffs_gif__decoder__frame_count(wuffs_gif__decoder* self);
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 //
|
||||
wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_reader a_src);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
|
||||
wuffs_base__image_buffer* a_dst,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src,
|
||||
wuffs_base__slice_u8 a_work_buffer);
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
uint32_t a_pixbuf_origin_x,
|
||||
uint32_t a_pixbuf_origin_y);
|
||||
|
||||
// ---------------- C++ Convenience Methods
|
||||
|
||||
@@ -2498,10 +2705,19 @@ wuffs_gif__decoder::work_buffer_size() {
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_gif__decoder::decode_frame(wuffs_base__image_buffer* a_dst,
|
||||
wuffs_gif__decoder::decode_frame_config(wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_reader a_src) {
|
||||
return wuffs_gif__decoder__decode_frame_config(this, a_dst, a_src);
|
||||
}
|
||||
|
||||
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) {
|
||||
return wuffs_gif__decoder__decode_frame(this, a_dst, a_src, a_work_buffer);
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
uint32_t a_pixbuf_origin_x,
|
||||
uint32_t a_pixbuf_origin_y) {
|
||||
return wuffs_gif__decoder__decode_frame(this, a_dst, a_src, a_work_buffer,
|
||||
a_pixbuf_origin_x, a_pixbuf_origin_y);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
@@ -6437,6 +6653,10 @@ static const uint8_t wuffs_gif__netscape2dot0[11] = {
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
|
||||
wuffs_base__io_reader a_src);
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self,
|
||||
wuffs_base__io_reader a_src);
|
||||
@@ -6471,12 +6691,12 @@ wuffs_gif__decoder__decode_id_part0(wuffs_gif__decoder* self,
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
wuffs_base__image_buffer* a_dst,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src);
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self,
|
||||
wuffs_base__image_buffer* a_ib);
|
||||
wuffs_base__pixel_buffer* a_pb);
|
||||
|
||||
// ---------------- Initializer Implementations
|
||||
|
||||
@@ -6632,13 +6852,199 @@ wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self) {
|
||||
0);
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.decode_frame_config
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_reader a_src) {
|
||||
if (!self) {
|
||||
return WUFFS_BASE__ERROR_BAD_RECEIVER;
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
self->private_impl.status =
|
||||
WUFFS_BASE__ERROR_CHECK_WUFFS_VERSION_NOT_CALLED;
|
||||
}
|
||||
if (self->private_impl.status < 0) {
|
||||
return self->private_impl.status;
|
||||
}
|
||||
wuffs_base__status status = WUFFS_BASE__STATUS_OK;
|
||||
|
||||
uint32_t coro_susp_point =
|
||||
self->private_impl.c_decode_frame_config[0].coro_susp_point;
|
||||
if (coro_susp_point) {
|
||||
} else {
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (!self->private_impl.f_end_of_data) {
|
||||
if (self->private_impl.f_call_sequence == 0) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_gif__decoder__decode_image_config(self, NULL, a_src);
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 1) {
|
||||
} else if (self->private_impl.f_call_sequence == 2) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_gif__decoder__skip_frame(self, a_src);
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
} else {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_end_of_data) {
|
||||
while (true) {
|
||||
status = WUFFS_BASE__SUSPENSION_END_OF_DATA;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(4);
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_use_local_palette ||
|
||||
self->private_impl.f_gc_has_transparent_index) {
|
||||
self->private_impl.f_which_palette = 1;
|
||||
} else if (!self->private_impl.f_previous_use_global_palette) {
|
||||
self->private_impl.f_which_palette = 0;
|
||||
} else {
|
||||
self->private_impl.f_which_palette = 2;
|
||||
}
|
||||
self->private_impl.f_previous_use_global_palette =
|
||||
!(self->private_impl.f_use_local_palette ||
|
||||
self->private_impl.f_gc_has_transparent_index);
|
||||
if (a_dst != NULL) {
|
||||
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_gc_duration, true,
|
||||
self->private_impl.f_gc_disposal,
|
||||
(self->private_impl.f_which_palette != 2));
|
||||
}
|
||||
self->private_impl.f_call_sequence = 2;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.c_decode_frame_config[0].coro_susp_point = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.c_decode_frame_config[0].coro_susp_point = coro_susp_point;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
self->private_impl.status = status;
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.skip_frame
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__skip_frame(wuffs_gif__decoder* self,
|
||||
wuffs_base__io_reader a_src) {
|
||||
wuffs_base__status status = WUFFS_BASE__STATUS_OK;
|
||||
|
||||
uint8_t v_lw;
|
||||
|
||||
uint8_t* ioptr_src = NULL;
|
||||
uint8_t* iobounds0orig_src = NULL;
|
||||
uint8_t* iobounds1_src = NULL;
|
||||
WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iobounds0orig_src);
|
||||
WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iobounds1_src);
|
||||
if (a_src.private_impl.buf) {
|
||||
ioptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
|
||||
if (!a_src.private_impl.bounds[0]) {
|
||||
a_src.private_impl.bounds[0] = ioptr_src;
|
||||
a_src.private_impl.bounds[1] =
|
||||
a_src.private_impl.buf->ptr + a_src.private_impl.buf->wi;
|
||||
}
|
||||
iobounds0orig_src = a_src.private_impl.bounds[0];
|
||||
iobounds1_src = a_src.private_impl.bounds[1];
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.c_skip_frame[0].coro_susp_point;
|
||||
if (coro_susp_point) {
|
||||
v_lw = self->private_impl.c_skip_frame[0].v_lw;
|
||||
} else {
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(ioptr_src == iobounds1_src)) {
|
||||
goto short_read_src;
|
||||
}
|
||||
uint8_t t_0 = *ioptr_src++;
|
||||
v_lw = t_0;
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
if (a_src.private_impl.buf) {
|
||||
a_src.private_impl.buf->ri = ioptr_src - a_src.private_impl.buf->ptr;
|
||||
}
|
||||
status = wuffs_gif__decoder__skip_blocks(self, a_src);
|
||||
if (a_src.private_impl.buf) {
|
||||
ioptr_src = a_src.private_impl.buf->ptr + a_src.private_impl.buf->ri;
|
||||
}
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_graphic_control = false;
|
||||
self->private_impl.f_gc_has_transparent_index = false;
|
||||
self->private_impl.f_gc_transparent_index = 0;
|
||||
self->private_impl.f_gc_disposal = 0;
|
||||
self->private_impl.f_gc_duration = 0;
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_frame_count_value,
|
||||
1);
|
||||
self->private_impl.f_call_sequence = 3;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.c_skip_frame[0].coro_susp_point = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.c_skip_frame[0].coro_susp_point = coro_susp_point;
|
||||
self->private_impl.c_skip_frame[0].v_lw = v_lw;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src.private_impl.buf) {
|
||||
a_src.private_impl.buf->ri = ioptr_src - a_src.private_impl.buf->ptr;
|
||||
}
|
||||
|
||||
return status;
|
||||
|
||||
short_read_src:
|
||||
if (wuffs_base__io_reader__is_eof(a_src)) {
|
||||
status = WUFFS_BASE__ERROR_UNEXPECTED_EOF;
|
||||
goto exit;
|
||||
}
|
||||
status = WUFFS_BASE__SUSPENSION_SHORT_READ;
|
||||
goto suspend;
|
||||
}
|
||||
|
||||
// -------- func gif.decoder.decode_frame
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
|
||||
wuffs_base__image_buffer* a_dst,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src,
|
||||
wuffs_base__slice_u8 a_work_buffer) {
|
||||
wuffs_base__slice_u8 a_work_buffer,
|
||||
uint32_t a_pixbuf_origin_x,
|
||||
uint32_t a_pixbuf_origin_y) {
|
||||
if (!self) {
|
||||
return WUFFS_BASE__ERROR_BAD_RECEIVER;
|
||||
}
|
||||
@@ -6663,37 +7069,26 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self,
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence == 0) {
|
||||
if (self->private_impl.f_call_sequence != 2) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_gif__decoder__decode_image_config(self, NULL, a_src);
|
||||
status = wuffs_gif__decoder__decode_frame_config(self, NULL, a_src);
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
if (!self->private_impl.f_end_of_data) {
|
||||
if (self->private_impl.f_call_sequence == 1) {
|
||||
self->private_impl.f_call_sequence = 2;
|
||||
} else {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_gif__decoder__decode_up_to_id_part1(self, a_src);
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (self->private_impl.f_end_of_data) {
|
||||
while (true) {
|
||||
status = WUFFS_BASE__SUSPENSION_END_OF_DATA;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(3);
|
||||
}
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_gif__decoder__decode_id_part1(self, a_dst, a_src);
|
||||
if (status) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_graphic_control = false;
|
||||
self->private_impl.f_gc_has_transparent_index = false;
|
||||
self->private_impl.f_gc_transparent_index = 0;
|
||||
self->private_impl.f_gc_disposal = 0;
|
||||
self->private_impl.f_gc_duration = 0;
|
||||
wuffs_base__u64__sat_add_indirect(&self->private_impl.f_frame_count_value,
|
||||
1);
|
||||
self->private_impl.f_call_sequence = 3;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
@@ -7927,7 +8322,7 @@ short_read_src:
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
wuffs_base__image_buffer* a_dst,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_reader a_src) {
|
||||
wuffs_base__status status = WUFFS_BASE__STATUS_OK;
|
||||
|
||||
@@ -7941,7 +8336,6 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(ioptr_w);
|
||||
WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iobounds1_w);
|
||||
wuffs_base__status v_z;
|
||||
wuffs_base__slice_u8 v_palette;
|
||||
|
||||
uint8_t* ioptr_src = NULL;
|
||||
uint8_t* iobounds0orig_src = NULL;
|
||||
@@ -7966,10 +8360,8 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
v_block_size = self->private_impl.c_decode_id_part1[0].v_block_size;
|
||||
v_w = ((wuffs_base__io_writer){});
|
||||
v_z = self->private_impl.c_decode_id_part1[0].v_z;
|
||||
v_palette = ((wuffs_base__slice_u8){});
|
||||
} else {
|
||||
v_w = ((wuffs_base__io_writer){});
|
||||
v_palette = ((wuffs_base__slice_u8){});
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
@@ -7995,6 +8387,11 @@ 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 & 1)],
|
||||
.len = 1024}));
|
||||
if (self->private_impl.f_previous_lzw_decode_ended_abruptly) {
|
||||
(memset(&self->private_impl.f_lzw, 0, sizeof((wuffs_lzw__decoder){})),
|
||||
wuffs_lzw__decoder__check_wuffs_version(&self->private_impl.f_lzw,
|
||||
@@ -8106,32 +8503,6 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self,
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
v_palette = ((wuffs_base__slice_u8){});
|
||||
if (self->private_impl.f_use_local_palette ||
|
||||
self->private_impl.f_gc_has_transparent_index) {
|
||||
v_palette = ((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_palettes[1], .len = 1024});
|
||||
} else if (!self->private_impl.f_previous_use_global_palette) {
|
||||
v_palette = ((wuffs_base__slice_u8){
|
||||
.ptr = self->private_impl.f_palettes[0], .len = 1024});
|
||||
}
|
||||
wuffs_base__image_buffer__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_gc_duration, true,
|
||||
self->private_impl.f_gc_disposal, v_palette);
|
||||
self->private_impl.f_previous_use_global_palette =
|
||||
!(self->private_impl.f_use_local_palette ||
|
||||
self->private_impl.f_gc_has_transparent_index);
|
||||
self->private_impl.f_seen_graphic_control = false;
|
||||
self->private_impl.f_gc_has_transparent_index = false;
|
||||
self->private_impl.f_gc_transparent_index = 0;
|
||||
self->private_impl.f_gc_disposal = 0;
|
||||
self->private_impl.f_gc_duration = 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
@@ -8167,7 +8538,7 @@ short_read_src:
|
||||
|
||||
static wuffs_base__status //
|
||||
wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self,
|
||||
wuffs_base__image_buffer* a_ib) {
|
||||
wuffs_base__pixel_buffer* a_pb) {
|
||||
wuffs_base__status status = WUFFS_BASE__STATUS_OK;
|
||||
|
||||
wuffs_base__slice_u8 v_dst;
|
||||
@@ -8180,7 +8551,7 @@ wuffs_gif__decoder__copy_to_image_buffer(wuffs_gif__decoder* self,
|
||||
v_src = ((wuffs_base__slice_u8){});
|
||||
v_n = 0;
|
||||
v_new_ri = 0;
|
||||
v_tab = wuffs_base__image_buffer__plane(a_ib, 0);
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_pb, 0);
|
||||
label_0_continue:;
|
||||
while (self->private_impl.f_uncompressed_wi >
|
||||
self->private_impl.f_uncompressed_ri) {
|
||||
|
||||
Reference in new issue
Block a user