diff --git a/release/c/wuffs-v0.2.h b/release/c/wuffs-v0.2.h index a2ef8a61..78cf3ddd 100644 --- a/release/c/wuffs-v0.2.h +++ b/release/c/wuffs-v0.2.h @@ -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) {