mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
release: wuffs gen -version=0.4.0-alpha.11
This commit is contained in:
1 parent
c677bef7fd
commit
2a6876f8bb
1 file changed
+3068
-1187
+3068
-1187
@@ -71,15 +71,15 @@ extern "C" {
|
||||
// each major.minor branch, the commit count should increase monotonically.
|
||||
//
|
||||
// WUFFS_VERSION was overridden by "wuffs gen -version" based on revision
|
||||
// f3de3336423f041ee251c3cf7f50a19b7eebb939 committed on 2026-06-23.
|
||||
// c677bef7fd69e8f336d1f3aa11eda63bcc29672a committed on 2026-10-18.
|
||||
#define WUFFS_VERSION 0x000040000
|
||||
#define WUFFS_VERSION_MAJOR 0
|
||||
#define WUFFS_VERSION_MINOR 4
|
||||
#define WUFFS_VERSION_PATCH 0
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.10"
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3966
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20260623
|
||||
#define WUFFS_VERSION_STRING "0.4.0-alpha.10+3966.20260623"
|
||||
#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.11"
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 4041
|
||||
#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20261018
|
||||
#define WUFFS_VERSION_STRING "0.4.0-alpha.11+4041.20261018"
|
||||
|
||||
// ---------------- Private Implementation Macros Re-definition Check
|
||||
|
||||
@@ -783,6 +783,9 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
// Primary Chromaticities and White Point.
|
||||
#define WUFFS_BASE__FOURCC__CHRM 0x4348524D
|
||||
|
||||
// Coding-Independent Code Points for video signal type identification.
|
||||
#define WUFFS_BASE__FOURCC__CICP 0x43494350
|
||||
|
||||
// Cascading Style Sheets.
|
||||
#define WUFFS_BASE__FOURCC__CSS 0x43535320
|
||||
|
||||
@@ -965,6 +968,17 @@ typedef struct wuffs_base__transform__output__struct {
|
||||
|
||||
// --------
|
||||
|
||||
// Various MIME types in 4/4/2 base-38 encoding, per
|
||||
// doc/note/enumerated-media-types.txt
|
||||
|
||||
// base38("appl/defl/..") = 0x9CC62_607F1000
|
||||
#define WUFFS_BASE__MIME_TYPE__APPLICATION_DEFLATE 2757997688197120
|
||||
|
||||
// base38("appl/octe/..") = 0x9CC62_A9E37800
|
||||
#define WUFFS_BASE__MIME_TYPE__APPLICATION_OCTET_STREAM 2757998919514112
|
||||
|
||||
// --------
|
||||
|
||||
// Quirks.
|
||||
|
||||
#define WUFFS_BASE__QUIRK_IGNORE_CHECKSUM 1
|
||||
@@ -1681,6 +1695,44 @@ wuffs_base__poke_u64le__no_bounds_check(uint8_t* p, uint64_t x) {
|
||||
#endif
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_base__pack_u8x8le_as_u64(uint8_t a0,
|
||||
uint8_t a1,
|
||||
uint8_t a2,
|
||||
uint8_t a3,
|
||||
uint8_t a4,
|
||||
uint8_t a5,
|
||||
uint8_t a6,
|
||||
uint8_t a7) {
|
||||
return (((uint64_t)a0) << 0) | //
|
||||
(((uint64_t)a1) << 8) | //
|
||||
(((uint64_t)a2) << 16) | //
|
||||
(((uint64_t)a3) << 24) | //
|
||||
(((uint64_t)a4) << 32) | //
|
||||
(((uint64_t)a5) << 40) | //
|
||||
(((uint64_t)a6) << 48) | //
|
||||
(((uint64_t)a7) << 56);
|
||||
}
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_base__pack_u16x4le_as_u64(uint16_t a0,
|
||||
uint16_t a1,
|
||||
uint16_t a2,
|
||||
uint16_t a3) {
|
||||
return (((uint64_t)a0) << 0) | //
|
||||
(((uint64_t)a1) << 16) | //
|
||||
(((uint64_t)a2) << 32) | //
|
||||
(((uint64_t)a3) << 48);
|
||||
}
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_base__pack_u32x2le_as_u64(uint32_t a0, uint32_t a1) {
|
||||
return (((uint64_t)a0) << 0) | //
|
||||
(((uint64_t)a1) << 32);
|
||||
}
|
||||
|
||||
// ---------------- Slices and Tables
|
||||
|
||||
// WUFFS_BASE__SLICE is a 1-dimensional buffer.
|
||||
@@ -1753,7 +1805,7 @@ wuffs_base__make_slice_u64(uint64_t* ptr, size_t len) {
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__make_slice_u8_ij(uint8_t* ptr, size_t i, size_t j) {
|
||||
wuffs_base__slice_u8 ret;
|
||||
ret.ptr = ptr ? (ptr + i) : NULL;
|
||||
ret.ptr = i ? (ptr + i) : ptr;
|
||||
ret.len = (j >= i) ? (j - i) : 0;
|
||||
return ret;
|
||||
}
|
||||
@@ -1761,7 +1813,7 @@ wuffs_base__make_slice_u8_ij(uint8_t* ptr, size_t i, size_t j) {
|
||||
static inline wuffs_base__slice_u16 //
|
||||
wuffs_base__make_slice_u16_ij(uint16_t* ptr, size_t i, size_t j) {
|
||||
wuffs_base__slice_u16 ret;
|
||||
ret.ptr = ptr ? (ptr + i) : NULL;
|
||||
ret.ptr = i ? (ptr + i) : ptr;
|
||||
ret.len = (j >= i) ? (j - i) : 0;
|
||||
return ret;
|
||||
}
|
||||
@@ -1769,7 +1821,7 @@ wuffs_base__make_slice_u16_ij(uint16_t* ptr, size_t i, size_t j) {
|
||||
static inline wuffs_base__slice_u32 //
|
||||
wuffs_base__make_slice_u32_ij(uint32_t* ptr, size_t i, size_t j) {
|
||||
wuffs_base__slice_u32 ret;
|
||||
ret.ptr = ptr ? (ptr + i) : NULL;
|
||||
ret.ptr = i ? (ptr + i) : ptr;
|
||||
ret.len = (j >= i) ? (j - i) : 0;
|
||||
return ret;
|
||||
}
|
||||
@@ -1777,7 +1829,7 @@ wuffs_base__make_slice_u32_ij(uint32_t* ptr, size_t i, size_t j) {
|
||||
static inline wuffs_base__slice_u64 //
|
||||
wuffs_base__make_slice_u64_ij(uint64_t* ptr, size_t i, size_t j) {
|
||||
wuffs_base__slice_u64 ret;
|
||||
ret.ptr = ptr ? (ptr + i) : NULL;
|
||||
ret.ptr = i ? (ptr + i) : ptr;
|
||||
ret.len = (j >= i) ? (j - i) : 0;
|
||||
return ret;
|
||||
}
|
||||
@@ -1918,7 +1970,12 @@ wuffs_base__slice_u8__overlaps(wuffs_base__slice_u8 s, wuffs_base__slice_u8 t) {
|
||||
static inline wuffs_base__slice_u8 //
|
||||
wuffs_base__slice_u8__subslice_i(wuffs_base__slice_u8 s, uint64_t i) {
|
||||
if ((i <= SIZE_MAX) && (i <= s.len)) {
|
||||
return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(s.len - i)));
|
||||
// The "i ? (s.ptr + i) : s.ptr" expression is equivalent to the plain
|
||||
// "s.ptr + i", except for the fact that in C (prior to C29), but not in
|
||||
// C++, "NULL + 0" is, technically, undefined behavior (and triggers
|
||||
// ubsan). See C29 N3322 and https://reviews.llvm.org/D67122
|
||||
return wuffs_base__make_slice_u8(i ? (s.ptr + i) : s.ptr,
|
||||
((size_t)(s.len - i)));
|
||||
}
|
||||
return wuffs_base__empty_slice_u8();
|
||||
}
|
||||
@@ -1942,7 +1999,12 @@ wuffs_base__slice_u8__subslice_ij(wuffs_base__slice_u8 s,
|
||||
uint64_t i,
|
||||
uint64_t j) {
|
||||
if ((i <= j) && (j <= SIZE_MAX) && (j <= s.len)) {
|
||||
return wuffs_base__make_slice_u8(s.ptr + i, ((size_t)(j - i)));
|
||||
// The "i ? (s.ptr + i) : s.ptr" expression is equivalent to the plain
|
||||
// "s.ptr + i", except for the fact that in C (prior to C29), but not in
|
||||
// C++, "NULL + 0" is, technically, undefined behavior (and triggers
|
||||
// ubsan). See C29 N3322 and https://reviews.llvm.org/D67122
|
||||
return wuffs_base__make_slice_u8(i ? (s.ptr + i) : s.ptr,
|
||||
((size_t)(j - i)));
|
||||
}
|
||||
return wuffs_base__empty_slice_u8();
|
||||
}
|
||||
@@ -3166,6 +3228,7 @@ typedef struct wuffs_base__more_information__struct {
|
||||
inline uint32_t metadata__fourcc() const;
|
||||
inline wuffs_base__range_ie_u64 metadata_raw_passthrough__range() const;
|
||||
inline int32_t metadata_parsed__chrm(uint32_t component) const;
|
||||
inline uint8_t metadata_parsed__cicp(uint32_t component) const;
|
||||
inline uint32_t metadata_parsed__gama() const;
|
||||
inline uint32_t metadata_parsed__srgb() const;
|
||||
#endif // __cplusplus
|
||||
@@ -3308,6 +3371,55 @@ wuffs_base__more_information__metadata_parsed__chrm(
|
||||
return ((int32_t)(u << 8)) >> 8;
|
||||
}
|
||||
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__COLOR_PRIMARIES 0
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__TRANSFER_FUNCTION 1
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__MATRIX_COEFFICIENTS \
|
||||
2
|
||||
#define WUFFS_BASE__MORE_INFORMATION__METADATA_PARSED__CICP__VIDEO_FULL_RANGE_FLAG \
|
||||
3
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__cicp returns
|
||||
// Coding-Independent Code Points values.
|
||||
//
|
||||
// - Component 0 is the Color Primaries.
|
||||
// - Component 1 is the Transfer Function.
|
||||
// - Component 2 is the Matrix Coefficients.
|
||||
// - Component 3 is the Video Full Range Flag.
|
||||
//
|
||||
// The (CP, TF) pair is the most interesting of these four. Some examples:
|
||||
//
|
||||
// - (CP: 1, TF: 1) is "bt.709".
|
||||
// - (CP: 1, TF: 8) is "linear-light-srgb".
|
||||
// - (CP: 1, TF: 13) is "srgb".
|
||||
// - (CP: 5, TF: 6) is "bt.601-pal".
|
||||
// - (CP: 6, TF: 6) is "bt.601-ntsc".
|
||||
// - (CP: 9, TF: 14) is "bt.2020-10-bit".
|
||||
// - (CP: 9, TF: 15) is "bt.2020-12-bit".
|
||||
// - (CP: 9, TF: 16) is "bt.2100-pq".
|
||||
// - (CP: 9, TF: 18) is "bt.2100-hlg".
|
||||
// - (CP: 11, TF: 17) is "dci-p3".
|
||||
// - (CP: 12, TF: 13) is "display-p3".
|
||||
// - (CP: 12, TF: 16) is "p3-d65-pq".
|
||||
//
|
||||
// For PNG, the MC value is always zero, as PNG uses the RGB color model. For
|
||||
// H.273, valid values include 0, 1, 5, 6 and 9. See the AOMediaCodec page.
|
||||
//
|
||||
// For PNG, the VFRF value is 0 (for narrow range) or 1 (for full range).
|
||||
//
|
||||
// See:
|
||||
//
|
||||
// - https://github.com/AOMediaCodec/libavif/wiki/CICP
|
||||
// - https://svgees.us/blog/cICP.html
|
||||
// - https://www.itu.int/rec/T-REC-H.273-202407-I
|
||||
// - https://www.w3.org/TR/png-3/#cICP-chunk
|
||||
static inline uint8_t //
|
||||
wuffs_base__more_information__metadata_parsed__cicp(
|
||||
const wuffs_base__more_information* m,
|
||||
uint32_t component) {
|
||||
int shift = 8 * (component & 3);
|
||||
return ((uint8_t)(m->x >> shift));
|
||||
}
|
||||
|
||||
// wuffs_base__more_information__metadata_parsed__gama returns inverse gamma
|
||||
// correction values (scaled by 100000) like the PNG "gAMA" chunk. For example,
|
||||
// for gamma = 2.2, this returns 45455 (approximating 100000 / 2.2).
|
||||
@@ -3372,6 +3484,11 @@ wuffs_base__more_information::metadata_parsed__chrm(uint32_t component) const {
|
||||
return wuffs_base__more_information__metadata_parsed__chrm(this, component);
|
||||
}
|
||||
|
||||
inline uint8_t //
|
||||
wuffs_base__more_information::metadata_parsed__cicp(uint32_t component) const {
|
||||
return wuffs_base__more_information__metadata_parsed__cicp(this, component);
|
||||
}
|
||||
|
||||
inline uint32_t //
|
||||
wuffs_base__more_information::metadata_parsed__gama() const {
|
||||
return wuffs_base__more_information__metadata_parsed__gama(this);
|
||||
@@ -3398,7 +3515,7 @@ typedef struct wuffs_base__io_buffer_meta__struct {
|
||||
} wuffs_base__io_buffer_meta;
|
||||
|
||||
// wuffs_base__io_buffer is a 1-dimensional buffer (a pointer and length) plus
|
||||
// additional metadata.
|
||||
// additional metadata. It is a linear buffer, not a circular buffer.
|
||||
//
|
||||
// A value with all fields zero is a valid, empty buffer.
|
||||
typedef struct wuffs_base__io_buffer__struct {
|
||||
@@ -4018,7 +4135,7 @@ typedef struct wuffs_base__token_buffer_meta__struct {
|
||||
} wuffs_base__token_buffer_meta;
|
||||
|
||||
// wuffs_base__token_buffer is a 1-dimensional buffer (a pointer and length)
|
||||
// plus additional metadata.
|
||||
// plus additional metadata. It is a linear buffer, not a circular buffer.
|
||||
//
|
||||
// A value with all fields zero is a valid, empty buffer.
|
||||
typedef struct wuffs_base__token_buffer__struct {
|
||||
@@ -4377,6 +4494,10 @@ wuffs_base__malloc_slice_u64(void* (*malloc_func)(size_t), uint64_t num_u64) {
|
||||
// 0xAARRGGBB (Alpha most significant, Blue least), regardless of endianness.
|
||||
typedef uint32_t wuffs_base__color_u32_argb_premul;
|
||||
|
||||
// wuffs_base__color_u32_argb_nonpremul is non-premultiplied version of
|
||||
// wuffs_base__color_u32_argb_premul.
|
||||
typedef uint32_t wuffs_base__color_u32_argb_nonpremul;
|
||||
|
||||
// wuffs_base__color_u32_argb_premul__is_valid returns whether c's Red, Green
|
||||
// and Blue channels are all less than or equal to its Alpha channel. c uses
|
||||
// premultiplied alpha, so 50% opaque 100% saturated red is 0x7F7F_0000 and a
|
||||
@@ -4596,6 +4717,21 @@ wuffs_base__color_u64_argb_premul__as__color_u64_argb_nonpremul(
|
||||
return (a << 48) | (r << 32) | (g << 16) | (b << 0);
|
||||
}
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_base__color_u64_argb_nonpremul__as__color_u64_argb_premul(
|
||||
uint64_t argb_nonpremul) {
|
||||
uint64_t a = 0xFFFF & (argb_nonpremul >> 48);
|
||||
|
||||
uint64_t r = 0xFFFF & (argb_nonpremul >> 32);
|
||||
r = (r * a) / 0xFFFF;
|
||||
uint64_t g = 0xFFFF & (argb_nonpremul >> 16);
|
||||
g = (g * a) / 0xFFFF;
|
||||
uint64_t b = 0xFFFF & (argb_nonpremul >> 0);
|
||||
b = (b * a) / 0xFFFF;
|
||||
|
||||
return (a << 48) | (r << 32) | (g << 16) | (b << 0);
|
||||
}
|
||||
|
||||
static inline uint8_t //
|
||||
wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray(
|
||||
uint64_t argb_nonpremul) {
|
||||
@@ -4827,6 +4963,11 @@ typedef uint8_t wuffs_base__pixel_blend;
|
||||
#define WUFFS_BASE__PIXEL_BLEND__SRC ((wuffs_base__pixel_blend)0)
|
||||
#define WUFFS_BASE__PIXEL_BLEND__SRC_OVER ((wuffs_base__pixel_blend)1)
|
||||
|
||||
static inline wuffs_base__pixel_blend //
|
||||
wuffs_base__make_pixel_blend(uint8_t repr) {
|
||||
return repr;
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
// wuffs_base__pixel_alpha_transparency is a pixel format's alpha channel
|
||||
@@ -5208,13 +5349,21 @@ wuffs_base__pixel_subsampling::denominator_y(uint32_t plane) const {
|
||||
//
|
||||
// For CMY, C = (100% - R), M = (100% - G) and Y = (100% - B). Black (K), if
|
||||
// present, then modulates the three RGB values.
|
||||
//
|
||||
// ----
|
||||
//
|
||||
// The 0x02 bit means the fourth channel is an alpha channel and, if set, then
|
||||
// the 0x01 bit gives the blend mode (WUFFS_BASE__PIXEL_BLEND__SRC is 0,
|
||||
// WUFFS_BASE__PIXEL_BLEND__SRC_OVER is 1).
|
||||
|
||||
// clang-format off
|
||||
|
||||
#define WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE 0x00
|
||||
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE 0x01
|
||||
#define WUFFS_BASE__YCC_MODEL__RGB 0x40
|
||||
#define WUFFS_BASE__YCC_MODEL__CMY 0x80
|
||||
#define WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE 0x00
|
||||
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE 0x04
|
||||
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC 0x06
|
||||
#define WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER 0x07
|
||||
#define WUFFS_BASE__YCC_MODEL__RGB 0x40
|
||||
#define WUFFS_BASE__YCC_MODEL__CMY 0x80
|
||||
|
||||
// clang-format on
|
||||
|
||||
@@ -5840,15 +5989,32 @@ typedef struct wuffs_base__pixel_buffer__struct {
|
||||
inline wuffs_base__slice_u8 palette_or_else(wuffs_base__slice_u8 fallback);
|
||||
inline wuffs_base__pixel_format pixel_format() const;
|
||||
inline wuffs_base__table_u8 plane(uint32_t p);
|
||||
// Deprecated: use color_u32_argb_premul_at.
|
||||
inline wuffs_base__color_u32_argb_premul color_u32_at(uint32_t x,
|
||||
uint32_t y) const;
|
||||
inline wuffs_base__color_u32_argb_premul color_u32_argb_premul_at(
|
||||
uint32_t x,
|
||||
uint32_t y) const;
|
||||
// Deprecated: use set_color_u32_argb_premul_at.
|
||||
inline wuffs_base__status set_color_u32_at(
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_premul color);
|
||||
inline wuffs_base__status set_color_u32_argb_premul_at(
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_premul color);
|
||||
// Deprecated: use set_color_u32_argb_premul_fill_rect.
|
||||
inline wuffs_base__status set_color_u32_fill_rect(
|
||||
wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul color);
|
||||
inline wuffs_base__status set_color_u32_argb_premul_fill_rect(
|
||||
wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul color);
|
||||
inline wuffs_base__status set_color_u32_argb_nonpremul_at(
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_nonpremul color);
|
||||
inline bool is_opaque();
|
||||
#endif // __cplusplus
|
||||
|
||||
@@ -6043,24 +6209,44 @@ wuffs_base__pixel_buffer__plane(wuffs_base__pixel_buffer* pb, uint32_t p) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Deprecated: use the second name, not the first.
|
||||
#define wuffs_base__pixel_buffer__color_u32_at \
|
||||
wuffs_base__pixel_buffer__color_u32_argb_premul_at
|
||||
|
||||
// Deprecated: use the second name, not the first.
|
||||
#define wuffs_base__pixel_buffer__set_color_u32_at \
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at
|
||||
|
||||
// Deprecated: use the second name, not the first.
|
||||
#define wuffs_base__pixel_buffer__set_color_u32_fill_rect \
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__color_u32_argb_premul //
|
||||
wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y);
|
||||
wuffs_base__pixel_buffer__color_u32_argb_premul_at(
|
||||
const wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_premul color);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_color_u32_fill_rect(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul color);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_nonpremul color);
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC bool //
|
||||
wuffs_base__pixel_buffer__is_opaque(const wuffs_base__pixel_buffer* pb);
|
||||
|
||||
@@ -6105,7 +6291,13 @@ wuffs_base__pixel_buffer::plane(uint32_t p) {
|
||||
|
||||
inline wuffs_base__color_u32_argb_premul //
|
||||
wuffs_base__pixel_buffer::color_u32_at(uint32_t x, uint32_t y) const {
|
||||
return wuffs_base__pixel_buffer__color_u32_at(this, x, y);
|
||||
return wuffs_base__pixel_buffer__color_u32_argb_premul_at(this, x, y);
|
||||
}
|
||||
|
||||
inline wuffs_base__color_u32_argb_premul //
|
||||
wuffs_base__pixel_buffer::color_u32_argb_premul_at(uint32_t x,
|
||||
uint32_t y) const {
|
||||
return wuffs_base__pixel_buffer__color_u32_argb_premul_at(this, x, y);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
@@ -6113,14 +6305,42 @@ wuffs_base__pixel_buffer::set_color_u32_at(
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_premul color) {
|
||||
return wuffs_base__pixel_buffer__set_color_u32_at(this, x, y, color);
|
||||
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(this, x, y,
|
||||
color);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_base__pixel_buffer::set_color_u32_argb_premul_at(
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_premul color) {
|
||||
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(this, x, y,
|
||||
color);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_base__pixel_buffer::set_color_u32_fill_rect(
|
||||
wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul color) {
|
||||
return wuffs_base__pixel_buffer__set_color_u32_fill_rect(this, rect, color);
|
||||
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
|
||||
this, rect, color);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_base__pixel_buffer::set_color_u32_argb_premul_fill_rect(
|
||||
wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul color) {
|
||||
return wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
|
||||
this, rect, color);
|
||||
}
|
||||
|
||||
inline wuffs_base__status //
|
||||
wuffs_base__pixel_buffer::set_color_u32_argb_nonpremul_at(
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_nonpremul color) {
|
||||
return wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(this, x, y,
|
||||
color);
|
||||
}
|
||||
|
||||
inline bool //
|
||||
@@ -13794,6 +14014,7 @@ struct wuffs_png__decoder__struct {
|
||||
uint64_t f_pass_workbuf_length;
|
||||
uint8_t f_call_sequence;
|
||||
bool f_report_metadata_chrm;
|
||||
bool f_report_metadata_cicp;
|
||||
bool f_report_metadata_exif;
|
||||
bool f_report_metadata_gama;
|
||||
bool f_report_metadata_iccp;
|
||||
@@ -13806,6 +14027,7 @@ struct wuffs_png__decoder__struct {
|
||||
uint8_t f_interlace_pass;
|
||||
bool f_seen_actl;
|
||||
bool f_seen_chrm;
|
||||
bool f_seen_cicp;
|
||||
bool f_seen_fctl;
|
||||
bool f_seen_exif;
|
||||
bool f_seen_gama;
|
||||
@@ -13871,6 +14093,7 @@ struct wuffs_png__decoder__struct {
|
||||
uint32_t p_decode_other_chunk;
|
||||
uint32_t p_decode_actl;
|
||||
uint32_t p_decode_chrm;
|
||||
uint32_t p_decode_cicp;
|
||||
uint32_t p_decode_fctl;
|
||||
uint32_t p_decode_gama;
|
||||
uint32_t p_decode_iccp;
|
||||
@@ -13913,6 +14136,9 @@ struct wuffs_png__decoder__struct {
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_chrm;
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_decode_cicp;
|
||||
struct {
|
||||
uint32_t v_x0;
|
||||
uint32_t v_x1;
|
||||
@@ -15458,7 +15684,9 @@ struct wuffs_thumbhash__decoder__struct {
|
||||
// ---------------- Status Codes
|
||||
|
||||
extern const char wuffs_vp8__error__bad_quirk_source_length[];
|
||||
extern const char wuffs_vp8__error__bad_quirk_width_and_height[];
|
||||
extern const char wuffs_vp8__error__bad_header[];
|
||||
extern const char wuffs_vp8__error__inconsistent_width_and_height[];
|
||||
extern const char wuffs_vp8__error__missing_quirk_source_length[];
|
||||
extern const char wuffs_vp8__error__truncated_input[];
|
||||
extern const char wuffs_vp8__error__unsupported_quirk_source_length[];
|
||||
@@ -15466,7 +15694,11 @@ extern const char wuffs_vp8__error__unsupported_vp8_file[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
#define WUFFS_VP8__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 553648127u
|
||||
#define WUFFS_VP8__QUIRK_HAS_ALPHA_SIDE_CHANNEL 1836840960u
|
||||
|
||||
#define WUFFS_VP8__QUIRK_WIDTH_AND_HEIGHT 1836840961u
|
||||
|
||||
#define WUFFS_VP8__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 822050816u
|
||||
|
||||
// ---------------- Struct Declarations
|
||||
|
||||
@@ -15637,8 +15869,10 @@ struct wuffs_vp8__decoder__struct {
|
||||
uint32_t f_mbh;
|
||||
uint8_t f_call_sequence;
|
||||
bool f_is_key_frame;
|
||||
bool f_quirk_has_alpha_side_channel;
|
||||
uint64_t f_frame_config_io_position;
|
||||
uint64_t f_quirk_source_length;
|
||||
uint64_t f_quirk_width_and_height;
|
||||
uint32_t f_partitioned_data_length;
|
||||
uint32_t f_workbuf_yuv_y_stride;
|
||||
uint32_t f_workbuf_yuv_uv_stride;
|
||||
@@ -16215,18 +16449,20 @@ struct wuffs_wbmp__decoder__struct {
|
||||
|
||||
// ---------------- Status Codes
|
||||
|
||||
extern const char wuffs_webp__error__bad_alph_vp8l_combination[];
|
||||
extern const char wuffs_webp__error__bad_huffman_code_over_subscribed[];
|
||||
extern const char wuffs_webp__error__bad_huffman_code_under_subscribed[];
|
||||
extern const char wuffs_webp__error__bad_huffman_code[];
|
||||
extern const char wuffs_webp__error__bad_vp8x_chunk[];
|
||||
extern const char wuffs_webp__error__bad_back_reference[];
|
||||
extern const char wuffs_webp__error__bad_chunk_order[];
|
||||
extern const char wuffs_webp__error__bad_color_cache[];
|
||||
extern const char wuffs_webp__error__bad_header[];
|
||||
extern const char wuffs_webp__error__bad_transform[];
|
||||
extern const char wuffs_webp__error__short_chunk[];
|
||||
extern const char wuffs_webp__error__truncated_input[];
|
||||
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
|
||||
extern const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[];
|
||||
extern const char wuffs_webp__error__unsupported_webp_file[];
|
||||
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
@@ -16395,16 +16631,19 @@ struct wuffs_webp__decoder__struct {
|
||||
wuffs_base__vtable vtable_for__wuffs_base__image_decoder;
|
||||
wuffs_base__vtable null_vtable;
|
||||
|
||||
uint32_t f_pixfmt;
|
||||
uint32_t f_width;
|
||||
uint32_t f_height;
|
||||
uint8_t f_call_sequence;
|
||||
uint8_t f_code_length_code_lengths[19];
|
||||
bool f_sub_chunk_has_padding;
|
||||
bool f_is_vp8_lossy;
|
||||
uint8_t f_variant;
|
||||
uint8_t f_vp8x_header_flags;
|
||||
uint8_t f_vp8x_alph_flags;
|
||||
uint64_t f_frame_config_io_position;
|
||||
uint32_t f_riff_chunk_length;
|
||||
uint32_t f_rcl_remaining;
|
||||
uint32_t f_sub_chunk_length;
|
||||
uint32_t f_sub_chunk_type;
|
||||
uint32_t f_bits;
|
||||
uint32_t f_n_bits;
|
||||
bool f_seen_transform[4];
|
||||
@@ -16423,24 +16662,28 @@ struct wuffs_webp__decoder__struct {
|
||||
uint32_t f_workbuf_offset_for_color_indexing;
|
||||
wuffs_base__pixel_swizzler f_swizzler;
|
||||
|
||||
uint32_t p_decode_alph;
|
||||
uint32_t p_decode_alph_limited;
|
||||
uint32_t p_decode_huffman_groups;
|
||||
uint32_t p_decode_huffman_tree;
|
||||
uint32_t p_decode_huffman_tree_simple;
|
||||
uint32_t p_decode_code_length_code_lengths;
|
||||
uint32_t p_build_code_lengths;
|
||||
uint32_t p_decode_pixels_slow;
|
||||
uint32_t p_decode_image_config;
|
||||
uint32_t p_do_decode_image_config;
|
||||
uint32_t p_do_decode_image_config_limited;
|
||||
uint32_t p_do_decode_image_config_limited_vp8l;
|
||||
uint32_t p_decode_frame_config;
|
||||
uint32_t p_do_decode_frame_config;
|
||||
uint32_t p_decode_frame;
|
||||
uint32_t p_do_decode_frame;
|
||||
uint32_t p_do_decode_frame_vp8l;
|
||||
uint32_t p_decode_transform;
|
||||
uint32_t p_decode_color_cache_parameters;
|
||||
uint32_t p_decode_hg_table;
|
||||
uint32_t p_decode_pixels;
|
||||
uint32_t p_decode_image_config;
|
||||
uint32_t p_do_decode_image_config;
|
||||
uint32_t p_do_decode_image_config_limited;
|
||||
uint32_t p_do_decode_image_config_limited_vp8l;
|
||||
uint32_t p_do_decode_image_config_limited_vp8x;
|
||||
uint32_t p_decode_frame_config;
|
||||
uint32_t p_do_decode_frame_config;
|
||||
uint32_t p_decode_frame;
|
||||
uint32_t p_do_decode_frame;
|
||||
} private_impl;
|
||||
|
||||
struct {
|
||||
@@ -16491,6 +16734,16 @@ struct wuffs_webp__decoder__struct {
|
||||
uint32_t v_back_ref_dist_premap_minus_1;
|
||||
uint64_t v_color_cache_p;
|
||||
} s_decode_pixels_slow;
|
||||
struct {
|
||||
uint32_t v_width;
|
||||
} s_do_decode_frame_vp8l;
|
||||
struct {
|
||||
uint32_t v_transform_type;
|
||||
uint32_t v_tile_size_log2;
|
||||
} s_decode_transform;
|
||||
struct {
|
||||
uint32_t v_tile_size_log2;
|
||||
} s_decode_hg_table;
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config;
|
||||
@@ -16501,15 +16754,11 @@ struct wuffs_webp__decoder__struct {
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config_limited_vp8l;
|
||||
struct {
|
||||
uint32_t v_width;
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config_limited_vp8x;
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_do_decode_frame;
|
||||
struct {
|
||||
uint32_t v_transform_type;
|
||||
uint32_t v_tile_size_log2;
|
||||
} s_decode_transform;
|
||||
struct {
|
||||
uint32_t v_tile_size_log2;
|
||||
} s_decode_hg_table;
|
||||
} private_data;
|
||||
|
||||
#ifdef __cplusplus
|
||||
@@ -17809,6 +18058,8 @@ class DecodeImageCallbacks {
|
||||
// should be at least len_range.min_incl, but larger allocations (up to
|
||||
// len_range.max_incl) may have better performance (by using more memory).
|
||||
//
|
||||
// The len_range argument will satisfy !len_range.is_empty().
|
||||
//
|
||||
// The default AllocWorkbuf implementation allocates len_range.max_incl bytes
|
||||
// of either uninitialized or zeroed memory.
|
||||
virtual AllocWorkbufResult //
|
||||
@@ -17881,27 +18132,29 @@ struct DecodeImageArgFlags {
|
||||
static constexpr uint64_t REPORT_METADATA_BGCL = 0x0001;
|
||||
// Primary Chromaticities and White Point.
|
||||
static constexpr uint64_t REPORT_METADATA_CHRM = 0x0002;
|
||||
// Coding-Independent Code Points for video signal type identification.
|
||||
static constexpr uint64_t REPORT_METADATA_CICP = 0x0004;
|
||||
// Exchangeable Image File Format.
|
||||
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0004;
|
||||
static constexpr uint64_t REPORT_METADATA_EXIF = 0x0008;
|
||||
// Gamma Correction.
|
||||
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0008;
|
||||
static constexpr uint64_t REPORT_METADATA_GAMA = 0x0010;
|
||||
// International Color Consortium Profile.
|
||||
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0010;
|
||||
static constexpr uint64_t REPORT_METADATA_ICCP = 0x0020;
|
||||
// Key-Value Pair.
|
||||
//
|
||||
// For PNG files, this includes iTXt, tEXt and zTXt chunks. In the
|
||||
// HandleMetadata callback, the raw argument contains UTF-8 strings.
|
||||
static constexpr uint64_t REPORT_METADATA_KVP = 0x0020;
|
||||
static constexpr uint64_t REPORT_METADATA_KVP = 0x0040;
|
||||
// Modification Time.
|
||||
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0040;
|
||||
static constexpr uint64_t REPORT_METADATA_MTIM = 0x0080;
|
||||
// Offset (2-Dimensional).
|
||||
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0080;
|
||||
static constexpr uint64_t REPORT_METADATA_OFS2 = 0x0100;
|
||||
// Physical Dimensions.
|
||||
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0100;
|
||||
static constexpr uint64_t REPORT_METADATA_PHYD = 0x0200;
|
||||
// Standard Red Green Blue (Rendering Intent).
|
||||
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0200;
|
||||
static constexpr uint64_t REPORT_METADATA_SRGB = 0x0400;
|
||||
// Extensible Metadata Platform.
|
||||
static constexpr uint64_t REPORT_METADATA_XMP = 0x0400;
|
||||
static constexpr uint64_t REPORT_METADATA_XMP = 0x0800;
|
||||
|
||||
uint64_t repr;
|
||||
};
|
||||
@@ -19174,13 +19427,19 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
uint8_t v2,
|
||||
uint8_t v3,
|
||||
uint8_t ycc_model,
|
||||
bool triangle_filter_for_2to1,
|
||||
uint8_t ycc_upsampling,
|
||||
wuffs_base__slice_u8 scratch_buffer_2k);
|
||||
|
||||
// ---------------- Images (Utility)
|
||||
|
||||
#define wuffs_base__utility__make_pixel_blend wuffs_base__make_pixel_blend
|
||||
#define wuffs_base__utility__make_pixel_format wuffs_base__make_pixel_format
|
||||
|
||||
static inline uint8_t //
|
||||
wuffs_base__utility__demake_pixel_blend(wuffs_base__pixel_blend a) {
|
||||
return a;
|
||||
}
|
||||
|
||||
// ---------------- String Conversions
|
||||
|
||||
// ---------------- Unicode and UTF-8
|
||||
@@ -24319,6 +24578,26 @@ wuffs_private_impl__swizzle_xxxx__y__x86_sse42(uint8_t* dst_ptr,
|
||||
|
||||
// --------
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(
|
||||
uint32_t dst_nonpremul,
|
||||
uint32_t src_nonpremul);
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(
|
||||
uint64_t dst_nonpremul,
|
||||
uint64_t src_nonpremul);
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(uint32_t dst_premul,
|
||||
uint32_t src_nonpremul);
|
||||
|
||||
static inline uint64_t //
|
||||
wuffs_private_impl__composite_premul_nonpremul_u64_axxx(uint64_t dst_premul,
|
||||
uint64_t src_nonpremul);
|
||||
|
||||
// --------
|
||||
|
||||
static inline uint32_t //
|
||||
wuffs_private_impl__color_u64__as__color_u32__swap_u32_argb_abgr(uint64_t c) {
|
||||
uint32_t a = ((uint32_t)(0xFF & (c >> 56)));
|
||||
@@ -24426,7 +24705,7 @@ wuffs_base__pixel_buffer__color_u32_at(const wuffs_base__pixel_buffer* pb,
|
||||
// --------
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
@@ -24539,6 +24818,365 @@ wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_nonpremul color) {
|
||||
if (!pb) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if ((x >= pb->pixcfg.private_impl.width) ||
|
||||
(y >= pb->pixcfg.private_impl.height)) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
|
||||
if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
|
||||
// TODO: support planar formats.
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
size_t stride = pb->private_impl.planes[0].stride;
|
||||
uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
|
||||
|
||||
switch (pb->pixcfg.private_impl.pixfmt.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRX:
|
||||
wuffs_base__poke_u32le__no_bounds_check(
|
||||
row + (4 * ((size_t)x)),
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color));
|
||||
break;
|
||||
|
||||
// Common formats above. Rarer formats below.
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y:
|
||||
wuffs_base__poke_u8__no_bounds_check(
|
||||
row + ((size_t)x),
|
||||
wuffs_base__color_u32_argb_premul__as__color_u8_gray(
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE:
|
||||
wuffs_base__poke_u16le__no_bounds_check(
|
||||
row + (2 * ((size_t)x)),
|
||||
wuffs_base__color_u32_argb_premul__as__color_u16_gray(
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE:
|
||||
wuffs_base__poke_u16be__no_bounds_check(
|
||||
row + (2 * ((size_t)x)),
|
||||
wuffs_base__color_u32_argb_premul__as__color_u16_gray(
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL:
|
||||
wuffs_base__poke_u8__no_bounds_check(
|
||||
row + (2 * ((size_t)x)),
|
||||
wuffs_base__color_u32_argb_premul__as__color_u8_gray(color |
|
||||
0xFF000000));
|
||||
wuffs_base__poke_u8__no_bounds_check(row + (2 * ((size_t)x)) + 1,
|
||||
((uint8_t)(color >> 24)));
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY:
|
||||
wuffs_base__poke_u8__no_bounds_check(
|
||||
row + ((size_t)x),
|
||||
wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__pixel_buffer__palette(pb),
|
||||
pb->pixcfg.private_impl.pixfmt,
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565:
|
||||
wuffs_base__poke_u16le__no_bounds_check(
|
||||
row + (2 * ((size_t)x)),
|
||||
wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR:
|
||||
wuffs_base__poke_u24le__no_bounds_check(
|
||||
row + (3 * ((size_t)x)),
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
wuffs_base__poke_u32le__no_bounds_check(row + (4 * ((size_t)x)), color);
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE:
|
||||
wuffs_base__poke_u64le__no_bounds_check(
|
||||
row + (8 * ((size_t)x)), wuffs_base__color_u32__as__color_u64(color));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE:
|
||||
wuffs_base__poke_u64le__no_bounds_check(
|
||||
row + (8 * ((size_t)x)),
|
||||
wuffs_base__color_u64_argb_nonpremul__as__color_u64_argb_premul(
|
||||
wuffs_base__color_u32__as__color_u64(color)));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY:
|
||||
wuffs_base__poke_u32le__no_bounds_check(
|
||||
row + (4 * ((size_t)x)),
|
||||
(color >> 31)
|
||||
? (wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color) |
|
||||
0xFF000000)
|
||||
: 0);
|
||||
break;
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGB:
|
||||
wuffs_base__poke_u24le__no_bounds_check(
|
||||
row + (3 * ((size_t)x)),
|
||||
wuffs_base__color_swap_u32_argb_abgr(
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL:
|
||||
wuffs_base__poke_u32le__no_bounds_check(
|
||||
row + (4 * ((size_t)x)), wuffs_base__color_swap_u32_argb_abgr(color));
|
||||
break;
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX:
|
||||
wuffs_base__poke_u32le__no_bounds_check(
|
||||
row + (4 * ((size_t)x)),
|
||||
wuffs_base__color_swap_u32_argb_abgr(
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color)));
|
||||
break;
|
||||
|
||||
default:
|
||||
// TODO: support more formats.
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
static inline wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__composite_color_u32_nonpremul_at(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
uint32_t x,
|
||||
uint32_t y,
|
||||
wuffs_base__color_u32_argb_nonpremul color) {
|
||||
if (!pb) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if ((x >= pb->pixcfg.private_impl.width) ||
|
||||
(y >= pb->pixcfg.private_impl.height)) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
|
||||
if (wuffs_base__pixel_format__is_planar(&pb->pixcfg.private_impl.pixfmt)) {
|
||||
// TODO: support planar formats.
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
size_t stride = pb->private_impl.planes[0].stride;
|
||||
uint8_t* row = pb->private_impl.planes[0].ptr + (stride * ((size_t)y));
|
||||
|
||||
switch (pb->pixcfg.private_impl.pixfmt.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRX: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr) | 0xFF000000;
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
// Common formats above. Rarer formats below.
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y: {
|
||||
uint8_t* ptr = row + ((size_t)x);
|
||||
uint32_t dst = 0xFF000000 | (0x00010101 * ((uint32_t)(*ptr)));
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
*ptr = ((uint8_t)(dst));
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y_16LE: {
|
||||
uint8_t* ptr = row + (2 * ((size_t)x));
|
||||
uint64_t dst =
|
||||
0xFFFF000000000000 |
|
||||
(0x000100010001 *
|
||||
((uint64_t)(wuffs_base__peek_u16le__no_bounds_check(ptr))));
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u64_axxx(
|
||||
dst, wuffs_base__color_u32__as__color_u64(color));
|
||||
wuffs_base__poke_u16le__no_bounds_check(ptr, ((uint16_t)(dst)));
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__Y_16BE: {
|
||||
uint8_t* ptr = row + (2 * ((size_t)x));
|
||||
uint64_t dst =
|
||||
0xFFFF000000000000 |
|
||||
(0x000100010001 *
|
||||
((uint64_t)(wuffs_base__peek_u16be__no_bounds_check(ptr))));
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u64_axxx(
|
||||
dst, wuffs_base__color_u32__as__color_u64(color));
|
||||
wuffs_base__poke_u16be__no_bounds_check(ptr, ((uint16_t)(dst)));
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: {
|
||||
uint8_t* ptr = row + (2 * ((size_t)x));
|
||||
uint32_t dst =
|
||||
(((uint32_t)(ptr[1])) << 24) | (((uint32_t)(ptr[0])) * 0x00010101);
|
||||
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(dst,
|
||||
color);
|
||||
ptr[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(dst |
|
||||
0xFF000000);
|
||||
ptr[1] = ((uint8_t)(dst >> 24));
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: {
|
||||
wuffs_base__slice_u8 palette = wuffs_base__pixel_buffer__palette(pb);
|
||||
if (palette.len) {
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(
|
||||
palette.ptr + (4 * ((size_t)row[x])));
|
||||
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(dst,
|
||||
color);
|
||||
row[x] = wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__pixel_buffer__palette(pb),
|
||||
pb->pixcfg.private_impl.pixfmt,
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
dst));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: {
|
||||
wuffs_base__slice_u8 palette = wuffs_base__pixel_buffer__palette(pb);
|
||||
if (palette.len) {
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(
|
||||
palette.ptr + (4 * ((size_t)row[x])));
|
||||
dst =
|
||||
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
row[x] = wuffs_base__pixel_palette__closest_element(
|
||||
wuffs_base__pixel_buffer__palette(pb),
|
||||
pb->pixcfg.private_impl.pixfmt, dst);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR_565: {
|
||||
uint8_t* ptr = row + (2 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul(
|
||||
wuffs_base__peek_u16le__no_bounds_check(ptr));
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
wuffs_base__poke_u16le__no_bounds_check(
|
||||
ptr, wuffs_base__color_u32_argb_premul__as__color_u16_rgb_565(dst));
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGR: {
|
||||
uint8_t* ptr = row + (3 * ((size_t)x));
|
||||
uint32_t dst = 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
wuffs_base__poke_u24le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(dst,
|
||||
color);
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: {
|
||||
uint8_t* ptr = row + (8 * ((size_t)x));
|
||||
uint64_t dst = wuffs_base__peek_u64le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u64_axxx(
|
||||
dst, wuffs_base__color_u32__as__color_u64(color));
|
||||
wuffs_base__poke_u64le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL_4X16LE: {
|
||||
uint8_t* ptr = row + (8 * ((size_t)x));
|
||||
uint64_t dst = wuffs_base__peek_u64le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u64_axxx(
|
||||
dst, wuffs_base__color_u32__as__color_u64(color));
|
||||
wuffs_base__poke_u64le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
|
||||
if (dst) {
|
||||
dst =
|
||||
wuffs_private_impl__composite_premul_nonpremul_u32_axxx(dst, color);
|
||||
} else if (color >> 31) {
|
||||
dst = (wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(
|
||||
color) |
|
||||
0xFF000000);
|
||||
}
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGB: {
|
||||
uint8_t* ptr = row + (3 * ((size_t)x));
|
||||
uint32_t dst = 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
|
||||
dst, wuffs_base__color_swap_u32_argb_abgr(color));
|
||||
wuffs_base__poke_u24le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_nonpremul_nonpremul_u32_axxx(
|
||||
dst, wuffs_base__color_swap_u32_argb_abgr(color));
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr);
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
|
||||
dst, wuffs_base__color_swap_u32_argb_abgr(color));
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
case WUFFS_BASE__PIXEL_FORMAT__RGBX: {
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst = wuffs_base__peek_u32le__no_bounds_check(ptr) | 0xFF000000;
|
||||
dst = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
|
||||
dst, wuffs_base__color_swap_u32_argb_abgr(color));
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
// TODO: support more formats.
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
static inline void //
|
||||
@@ -24666,7 +25304,7 @@ wuffs_private_impl__pixel_buffer__set_color_u32_fill_rect__xxxxxxxx(
|
||||
}
|
||||
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status //
|
||||
wuffs_base__pixel_buffer__set_color_u32_fill_rect(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_fill_rect(
|
||||
wuffs_base__pixel_buffer* pb,
|
||||
wuffs_base__rect_ie_u32 rect,
|
||||
wuffs_base__color_u32_argb_premul color) {
|
||||
@@ -24738,7 +25376,7 @@ wuffs_base__pixel_buffer__set_color_u32_fill_rect(
|
||||
for (y = rect.min_incl_y; y < rect.max_excl_y; y++) {
|
||||
uint32_t x;
|
||||
for (x = rect.min_incl_x; x < rect.max_excl_x; x++) {
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(pb, x, y, color);
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(pb, x, y, color);
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
@@ -32371,7 +33009,36 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column);
|
||||
bool last_column,
|
||||
uint8_t odd_column_rounding);
|
||||
|
||||
static const uint8_t* //
|
||||
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2(
|
||||
uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr_major,
|
||||
const uint8_t* src_ptr_minor,
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
|
||||
first_column, last_column, 7);
|
||||
}
|
||||
|
||||
static const uint8_t* //
|
||||
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2(
|
||||
uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr_major,
|
||||
const uint8_t* src_ptr_minor,
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
|
||||
first_column, last_column, 8);
|
||||
}
|
||||
#endif
|
||||
#endif // defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
|
||||
|
||||
@@ -32412,6 +33079,102 @@ typedef void (*wuffs_private_impl__swizzle_ycc__convert_4_func)(
|
||||
const uint8_t* up2,
|
||||
const uint8_t* up3);
|
||||
|
||||
static void //
|
||||
wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_general(
|
||||
wuffs_base__pixel_buffer* dst,
|
||||
uint32_t x,
|
||||
uint32_t x_end,
|
||||
uint32_t y,
|
||||
const uint8_t* up0,
|
||||
const uint8_t* up1,
|
||||
const uint8_t* up2,
|
||||
const uint8_t* up3) {
|
||||
for (; x < x_end; x++) {
|
||||
uint32_t color = //
|
||||
wuffs_base__color_ycc_bt601sr__as__color_u32( //
|
||||
*up0++, *up1++, *up2++);
|
||||
color &= 0xFFFFFFu;
|
||||
color |= ((uint32_t)(*up3++)) << 24;
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_nonpremul_at(dst, x, y, color);
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_bgra_premul(
|
||||
wuffs_base__pixel_buffer* dst,
|
||||
uint32_t x,
|
||||
uint32_t x_end,
|
||||
uint32_t y,
|
||||
const uint8_t* up0,
|
||||
const uint8_t* up1,
|
||||
const uint8_t* up2,
|
||||
const uint8_t* up3) {
|
||||
size_t stride = dst->private_impl.planes[0].stride;
|
||||
uint8_t* row = dst->private_impl.planes[0].ptr + (stride * ((size_t)y));
|
||||
|
||||
for (; x < x_end; x++) {
|
||||
uint32_t color = //
|
||||
wuffs_base__color_ycc_bt601sr__as__color_u32( //
|
||||
*up0++, *up1++, *up2++);
|
||||
color &= 0xFFFFFFu;
|
||||
color |= ((uint32_t)(*up3++)) << 24;
|
||||
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst_color =
|
||||
wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(color);
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst_color);
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_general(
|
||||
wuffs_base__pixel_buffer* dst,
|
||||
uint32_t x,
|
||||
uint32_t x_end,
|
||||
uint32_t y,
|
||||
const uint8_t* up0,
|
||||
const uint8_t* up1,
|
||||
const uint8_t* up2,
|
||||
const uint8_t* up3) {
|
||||
for (; x < x_end; x++) {
|
||||
uint32_t color = //
|
||||
wuffs_base__color_ycc_bt601sr__as__color_u32( //
|
||||
*up0++, *up1++, *up2++);
|
||||
color &= 0xFFFFFFu;
|
||||
color |= ((uint32_t)(*up3++)) << 24;
|
||||
wuffs_base__pixel_buffer__composite_color_u32_nonpremul_at(dst, x, y,
|
||||
color);
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_bgra_premul(
|
||||
wuffs_base__pixel_buffer* dst,
|
||||
uint32_t x,
|
||||
uint32_t x_end,
|
||||
uint32_t y,
|
||||
const uint8_t* up0,
|
||||
const uint8_t* up1,
|
||||
const uint8_t* up2,
|
||||
const uint8_t* up3) {
|
||||
size_t stride = dst->private_impl.planes[0].stride;
|
||||
uint8_t* row = dst->private_impl.planes[0].ptr + (stride * ((size_t)y));
|
||||
|
||||
for (; x < x_end; x++) {
|
||||
uint32_t color = //
|
||||
wuffs_base__color_ycc_bt601sr__as__color_u32( //
|
||||
*up0++, *up1++, *up2++);
|
||||
color &= 0xFFFFFFu;
|
||||
color |= ((uint32_t)(*up3++)) << 24;
|
||||
|
||||
uint8_t* ptr = row + (4 * ((size_t)x));
|
||||
uint32_t dst_color = wuffs_base__peek_u32le__no_bounds_check(ptr);
|
||||
dst_color = wuffs_private_impl__composite_premul_nonpremul_u32_axxx(
|
||||
dst_color, color);
|
||||
wuffs_base__poke_u32le__no_bounds_check(ptr, dst_color);
|
||||
}
|
||||
}
|
||||
|
||||
static void //
|
||||
wuffs_private_impl__swizzle_cmyk__convert_4_general(
|
||||
wuffs_base__pixel_buffer* dst,
|
||||
@@ -32433,7 +33196,7 @@ wuffs_private_impl__swizzle_cmyk__convert_4_general(
|
||||
r = ((r * w) + 0x7Fu) / 0xFFu;
|
||||
g = ((g * w) + 0x7Fu) / 0xFFu;
|
||||
b = ((b * w) + 0x7Fu) / 0xFFu;
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
dst, x, y, 0xFF000000u | (r << 16u) | (g << 8u) | (b << 0u));
|
||||
}
|
||||
}
|
||||
@@ -32460,7 +33223,7 @@ wuffs_private_impl__swizzle_ycck__convert_4_general(
|
||||
r = ((r * w) + 0x7Fu) / 0xFFu;
|
||||
g = ((g * w) + 0x7Fu) / 0xFFu;
|
||||
b = ((b * w) + 0x7Fu) / 0xFFu;
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(
|
||||
dst, x, y, 0xFF000000u | (r << 16u) | (g << 8u) | (b << 0u));
|
||||
}
|
||||
}
|
||||
@@ -32490,7 +33253,7 @@ wuffs_private_impl__swizzle_rgb__convert_3_general(
|
||||
(((uint32_t)(*up0++)) << 16u) | //
|
||||
(((uint32_t)(*up1++)) << 8u) | //
|
||||
(((uint32_t)(*up2++)) << 0u);
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32507,7 +33270,7 @@ wuffs_private_impl__swizzle_ycc_bt601fr__convert_3_general(
|
||||
uint32_t color = //
|
||||
wuffs_base__color_ycc_bt601fr__as__color_u32( //
|
||||
*up0++, *up1++, *up2++);
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32568,7 +33331,7 @@ wuffs_private_impl__swizzle_ycc_bt601sr__convert_3_general(
|
||||
uint32_t color = //
|
||||
wuffs_base__color_ycc_bt601sr__as__color_u32( //
|
||||
*up0++, *up1++, *up2++);
|
||||
wuffs_base__pixel_buffer__set_color_u32_at(dst, x, y, color);
|
||||
wuffs_base__pixel_buffer__set_color_u32_argb_premul_at(dst, x, y, color);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32730,8 +33493,8 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle(
|
||||
const uint8_t* src_ptr_minor,
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
bool first_column_ignored,
|
||||
bool last_column_ignored) {
|
||||
uint8_t* dp = dst_ptr;
|
||||
const uint8_t* sp_major = src_ptr_major;
|
||||
const uint8_t* sp_minor = src_ptr_minor;
|
||||
@@ -32803,10 +33566,12 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
bool last_column,
|
||||
uint8_t odd_column_rounding) {
|
||||
uint8_t* dp = dst_ptr;
|
||||
const uint8_t* sp_major = src_ptr_major;
|
||||
const uint8_t* sp_minor = src_ptr_minor;
|
||||
const uint8_t oc = odd_column_rounding;
|
||||
|
||||
if (first_column) {
|
||||
src_len--;
|
||||
@@ -32814,7 +33579,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + //
|
||||
(4u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + oc) >> 4u);
|
||||
return dst_ptr;
|
||||
}
|
||||
|
||||
@@ -32826,7 +33591,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
||||
(3u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
|
||||
if (src_len <= 0u) {
|
||||
return dst_ptr;
|
||||
}
|
||||
@@ -32845,7 +33610,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
||||
(3u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
|
||||
}
|
||||
|
||||
if (last_column) {
|
||||
@@ -32857,12 +33622,40 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
||||
(3u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
|
||||
}
|
||||
|
||||
return dst_ptr;
|
||||
}
|
||||
|
||||
static const uint8_t* //
|
||||
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg(
|
||||
uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr_major,
|
||||
const uint8_t* src_ptr_minor,
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
|
||||
first_column, last_column, 7);
|
||||
}
|
||||
|
||||
static const uint8_t* //
|
||||
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp(
|
||||
uint8_t* dst_ptr,
|
||||
const uint8_t* src_ptr_major,
|
||||
const uint8_t* src_ptr_minor,
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
return wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle(
|
||||
dst_ptr, src_ptr_major, src_ptr_minor, src_len, h1v2_bias_ignored,
|
||||
first_column, last_column, 8);
|
||||
}
|
||||
|
||||
// wuffs_private_impl__swizzle_ycc__upsample_funcs is indexed by inv_h and then
|
||||
// inv_v.
|
||||
static const wuffs_private_impl__swizzle_ycc__upsample_func
|
||||
@@ -33614,7 +34407,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
uint8_t v2,
|
||||
uint8_t v3,
|
||||
uint8_t ycc_model,
|
||||
bool triangle_filter_for_2to1,
|
||||
uint8_t ycc_upsampling,
|
||||
wuffs_base__slice_u8 scratch_buffer_2k) {
|
||||
if (!p) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
@@ -33629,7 +34422,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
(4u <= ((unsigned int)v0 - 1u)) || //
|
||||
(4u <= ((unsigned int)v1 - 1u)) || //
|
||||
(4u <= ((unsigned int)v2 - 1u)) || //
|
||||
(triangle_filter_for_2to1 && ((x_min_incl | y_min_incl) > 0u)) ||
|
||||
((ycc_upsampling != 0) && ((x_min_incl | y_min_incl) > 0u)) ||
|
||||
(scratch_buffer_2k.len < 2048u)) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
@@ -33744,7 +34537,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
}
|
||||
|
||||
if (wuffs_base__pixel_format__is_planar(&dst->pixcfg.private_impl.pixfmt)) {
|
||||
// TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO.
|
||||
// TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's TODO.
|
||||
return wuffs_base__make_status(
|
||||
wuffs_base__error__unsupported_pixel_swizzler_option);
|
||||
}
|
||||
@@ -33819,7 +34612,8 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
break;
|
||||
|
||||
default:
|
||||
// TODO: see wuffs_base__pixel_buffer__set_color_u32_at's TODO.
|
||||
// TODO: see wuffs_base__pixel_buffer__set_color_u32_argb_premul_at's
|
||||
// TODO.
|
||||
return wuffs_base__make_status(
|
||||
wuffs_base__error__unsupported_pixel_swizzler_option);
|
||||
}
|
||||
@@ -33832,7 +34626,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
if (ycc_model >= WUFFS_BASE__YCC_MODEL__RGB) {
|
||||
conv3func = &wuffs_private_impl__swizzle_rgb__convert_3_general;
|
||||
|
||||
} else if (ycc_model == WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
|
||||
} else if (ycc_model >= WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
|
||||
switch (dst->pixcfg.private_impl.pixfmt.repr) {
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL:
|
||||
case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL:
|
||||
@@ -33937,7 +34731,7 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
memcpy(&upfuncs, &wuffs_private_impl__swizzle_ycc__upsample_funcs,
|
||||
sizeof upfuncs);
|
||||
|
||||
if (triangle_filter_for_2to1 &&
|
||||
if ((ycc_upsampling != 0) &&
|
||||
(wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h0, inv_v0) ||
|
||||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h1, inv_v1) ||
|
||||
wuffs_private_impl__swizzle_has_triangle_upsampler(inv_h2, inv_v2) ||
|
||||
@@ -33947,7 +34741,10 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
|
||||
upfuncs[0][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h1v2_triangle;
|
||||
upfuncs[1][0] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v1_triangle;
|
||||
upfuncs[1][1] = wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle;
|
||||
upfuncs[1][1] =
|
||||
(ycc_upsampling == 1)
|
||||
? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg
|
||||
: wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp;
|
||||
|
||||
#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V3)
|
||||
#if defined(__GNUC__) && !defined(__clang__)
|
||||
@@ -33965,21 +34762,48 @@ wuffs_base__pixel_swizzler__swizzle_ycck(
|
||||
#else
|
||||
if (wuffs_base__cpu_arch__have_x86_avx2()) {
|
||||
upfuncs[1][1] =
|
||||
wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2;
|
||||
(ycc_upsampling == 1)
|
||||
? wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libjpeg_x86_avx2
|
||||
: wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_libwebp_x86_avx2;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
if ((h3 != 0u) || (v3 != 0u)) {
|
||||
if (ycc_model == WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE) {
|
||||
return wuffs_base__make_status(
|
||||
wuffs_base__error__unsupported_pixel_swizzler_option);
|
||||
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func = NULL;
|
||||
switch (ycc_model) {
|
||||
case WUFFS_BASE__YCC_MODEL__BT_601_FULL_RANGE:
|
||||
conv4func = &wuffs_private_impl__swizzle_ycck__convert_4_general;
|
||||
break;
|
||||
case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC:
|
||||
if (dst->pixcfg.private_impl.pixfmt.repr ==
|
||||
WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) {
|
||||
conv4func =
|
||||
&wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_bgra_premul;
|
||||
} else {
|
||||
conv4func =
|
||||
&wuffs_private_impl__swizzle_ycca_bt601sr_src__convert_4_general;
|
||||
}
|
||||
break;
|
||||
case WUFFS_BASE__YCC_MODEL__BT_601_STUDIO_RANGE__ALPHA__SRC_OVER:
|
||||
if (dst->pixcfg.private_impl.pixfmt.repr ==
|
||||
WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL) {
|
||||
conv4func =
|
||||
&wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_bgra_premul;
|
||||
} else {
|
||||
conv4func =
|
||||
&wuffs_private_impl__swizzle_ycca_bt601sr_src_over__convert_4_general;
|
||||
}
|
||||
break;
|
||||
case WUFFS_BASE__YCC_MODEL__CMY:
|
||||
conv4func = &wuffs_private_impl__swizzle_cmyk__convert_4_general;
|
||||
break;
|
||||
default:
|
||||
return wuffs_base__make_status(
|
||||
wuffs_base__error__unsupported_pixel_swizzler_option);
|
||||
}
|
||||
wuffs_private_impl__swizzle_ycc__convert_4_func conv4func =
|
||||
(ycc_model >= WUFFS_BASE__YCC_MODEL__RGB)
|
||||
? &wuffs_private_impl__swizzle_cmyk__convert_4_general
|
||||
: &wuffs_private_impl__swizzle_ycck__convert_4_general;
|
||||
|
||||
(*func4)( //
|
||||
dst, x_min_incl, x_max_excl, y_min_incl, y_max_excl, //
|
||||
src0.ptr, src1.ptr, src2.ptr, src3.ptr, //
|
||||
@@ -34440,10 +35264,12 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
size_t src_len,
|
||||
uint32_t h1v2_bias_ignored,
|
||||
bool first_column,
|
||||
bool last_column) {
|
||||
bool last_column,
|
||||
uint8_t odd_column_rounding) {
|
||||
uint8_t* dp = dst_ptr;
|
||||
const uint8_t* sp_major = src_ptr_major;
|
||||
const uint8_t* sp_minor = src_ptr_minor;
|
||||
const uint8_t oc = odd_column_rounding;
|
||||
|
||||
if (first_column) {
|
||||
src_len--;
|
||||
@@ -34451,7 +35277,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
uint32_t sv = (12u * ((uint32_t)(*sp_major++))) + //
|
||||
(4u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + oc) >> 4u);
|
||||
return dst_ptr;
|
||||
}
|
||||
|
||||
@@ -34463,7 +35289,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
||||
(3u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
|
||||
if (src_len <= 0u) {
|
||||
return dst_ptr;
|
||||
}
|
||||
@@ -34484,7 +35310,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
||||
(3u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
|
||||
}
|
||||
|
||||
} else {
|
||||
@@ -34557,8 +35383,8 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
// the u16 right value by 4. On the right (p1), shift right by 4 and then
|
||||
// shift left by 8 so that, when still in the u16x16 little-endian
|
||||
// interpretation, we have:
|
||||
// - m1_element = (etcetera + 8) >> 4
|
||||
// - p1_element = ((etcetera + 7) >> 4) << 8
|
||||
// - m1_element = (etcetera + 8) >> 4
|
||||
// - p1_element = ((etcetera + oc) >> 4) << 8
|
||||
//
|
||||
// step4_m1_lo = [0x00?? 0x00?? ... 0x00?? 0x00??]
|
||||
// step4_p1_lo = [0x??00 0x??00 ... 0x??00 0x??00]
|
||||
@@ -34567,14 +35393,14 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
__m256i step4_m1_lo = _mm256_srli_epi16(
|
||||
_mm256_add_epi16(step3_m1_lo, _mm256_set1_epi16(8)), 4);
|
||||
__m256i step4_p1_lo = _mm256_slli_epi16(
|
||||
_mm256_srli_epi16(_mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(7)),
|
||||
4),
|
||||
_mm256_srli_epi16(
|
||||
_mm256_add_epi16(step3_p1_lo, _mm256_set1_epi16(oc)), 4),
|
||||
8);
|
||||
__m256i step4_m1_hi = _mm256_srli_epi16(
|
||||
_mm256_add_epi16(step3_m1_hi, _mm256_set1_epi16(8)), 4);
|
||||
__m256i step4_p1_hi = _mm256_slli_epi16(
|
||||
_mm256_srli_epi16(_mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(7)),
|
||||
4),
|
||||
_mm256_srli_epi16(
|
||||
_mm256_add_epi16(step3_p1_hi, _mm256_set1_epi16(oc)), 4),
|
||||
8);
|
||||
|
||||
// Bitwise-or two "0x00"-rich u16x16 vectors to get a u8x32 vector. Do
|
||||
@@ -34625,7 +35451,7 @@ wuffs_private_impl__swizzle_ycc__upsample_inv_h2v2_triangle_x86_avx2(
|
||||
uint32_t sv = (9u * ((uint32_t)(*sp_major++))) + //
|
||||
(3u * ((uint32_t)(*sp_minor++)));
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_m1) + (sv_minor_m1) + 8u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + 7u) >> 4u);
|
||||
*dp++ = (uint8_t)((sv + (3u * sv_major_p1) + (sv_minor_p1) + oc) >> 4u);
|
||||
}
|
||||
|
||||
return dst_ptr;
|
||||
@@ -35239,14 +36065,14 @@ wuffs_adler32__hasher__up_arm_neon(
|
||||
v_p.len = 0;
|
||||
}
|
||||
v_v2 = vshlq_n_u32(v_v2, 5u);
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col0), ((uint16x4_t){32u, 31u, 30u, 29u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col0), ((uint16x4_t){28u, 27u, 26u, 25u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col1), ((uint16x4_t){24u, 23u, 22u, 21u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col1), ((uint16x4_t){20u, 19u, 18u, 17u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col2), ((uint16x4_t){16u, 15u, 14u, 13u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col2), ((uint16x4_t){12u, 11u, 10u, 9u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col3), ((uint16x4_t){8u, 7u, 6u, 5u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col3), ((uint16x4_t){4u, 3u, 2u, 1u}));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col0), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(32u, 31u, 30u, 29u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col0), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(28u, 27u, 26u, 25u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col1), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(24u, 23u, 22u, 21u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col1), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(20u, 19u, 18u, 17u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col2), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(16u, 15u, 14u, 13u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col2), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(12u, 11u, 10u, 9u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_low_u16(v_col3), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(8u, 7u, 6u, 5u))));
|
||||
v_v2 = vmlal_u16(v_v2, vget_high_u16(v_col3), vreinterpret_u16_u64(vcreate_u64(wuffs_base__pack_u16x4le_as_u64(4u, 3u, 2u, 1u))));
|
||||
v_sum1 = vpadd_u32(vget_low_u32(v_v1), vget_high_u32(v_v1));
|
||||
v_sum2 = vpadd_u32(vget_low_u32(v_v2), vget_high_u32(v_v2));
|
||||
v_sum12 = vpadd_u32(v_sum1, v_sum2);
|
||||
@@ -50632,42 +51458,6 @@ WUFFS_HANDSUM__ZIGZAG[2][15] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
},
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_HANDSUM__SCALE_AND_BIAS_CHROMA_DOWN[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
60u, 60u, 61u, 61u, 62u, 62u, 63u, 63u,
|
||||
64u, 64u, 65u, 65u, 66u, 66u, 67u, 67u,
|
||||
68u, 68u, 69u, 69u, 70u, 70u, 71u, 71u,
|
||||
72u, 72u, 73u, 73u, 74u, 74u, 75u, 75u,
|
||||
76u, 76u, 77u, 77u, 78u, 78u, 79u, 79u,
|
||||
80u, 80u, 81u, 81u, 82u, 82u, 83u, 83u,
|
||||
84u, 84u, 85u, 85u, 86u, 86u, 87u, 87u,
|
||||
88u, 88u, 89u, 89u, 90u, 90u, 91u, 91u,
|
||||
92u, 92u, 93u, 93u, 94u, 94u, 95u, 95u,
|
||||
96u, 96u, 97u, 97u, 98u, 98u, 99u, 99u,
|
||||
100u, 100u, 101u, 101u, 102u, 102u, 103u, 103u,
|
||||
104u, 104u, 105u, 105u, 106u, 106u, 107u, 107u,
|
||||
108u, 108u, 109u, 109u, 110u, 110u, 111u, 111u,
|
||||
112u, 112u, 113u, 113u, 114u, 114u, 115u, 115u,
|
||||
116u, 116u, 117u, 117u, 118u, 118u, 119u, 119u,
|
||||
120u, 120u, 121u, 121u, 122u, 122u, 123u, 123u,
|
||||
124u, 124u, 125u, 125u, 126u, 126u, 127u, 127u,
|
||||
128u, 128u, 129u, 129u, 130u, 130u, 131u, 131u,
|
||||
132u, 132u, 133u, 133u, 134u, 134u, 135u, 135u,
|
||||
136u, 136u, 137u, 137u, 138u, 138u, 139u, 139u,
|
||||
140u, 140u, 141u, 141u, 142u, 142u, 143u, 143u,
|
||||
144u, 144u, 145u, 145u, 146u, 146u, 147u, 147u,
|
||||
148u, 148u, 149u, 149u, 150u, 150u, 151u, 151u,
|
||||
152u, 152u, 153u, 153u, 154u, 154u, 155u, 155u,
|
||||
156u, 156u, 157u, 157u, 158u, 158u, 159u, 159u,
|
||||
160u, 160u, 161u, 161u, 162u, 162u, 163u, 163u,
|
||||
164u, 164u, 165u, 165u, 166u, 166u, 167u, 167u,
|
||||
168u, 168u, 169u, 169u, 170u, 170u, 171u, 171u,
|
||||
172u, 172u, 173u, 173u, 174u, 174u, 175u, 175u,
|
||||
176u, 176u, 177u, 177u, 178u, 178u, 179u, 179u,
|
||||
180u, 180u, 181u, 181u, 182u, 182u, 183u, 183u,
|
||||
184u, 184u, 185u, 185u, 186u, 186u, 187u, 187u,
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_HANDSUM__CUBE_ROOT[256] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
0u, 0u, 1u, 1u, 1u, 2u, 2u, 2u,
|
||||
@@ -52176,8 +52966,8 @@ wuffs_handsum__decoder__scale_and_bias_chroma_down(
|
||||
while (v_y < 8u) {
|
||||
v_x = 0u;
|
||||
while (v_x < 8u) {
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] = WUFFS_HANDSUM__SCALE_AND_BIAS_CHROMA_DOWN[self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)]];
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] = WUFFS_HANDSUM__SCALE_AND_BIAS_CHROMA_DOWN[self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)]];
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] = ((uint8_t)(60u + ((uint8_t)(self->private_data.f_buffers[1u][v_y][((4u * v_x) + 1u)] >> 1u))));
|
||||
self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] = ((uint8_t)(60u + ((uint8_t)(self->private_data.f_buffers[1u][v_y][((4u * v_x) + 2u)] >> 1u))));
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
@@ -57761,6 +58551,7 @@ wuffs_jpeg__decoder__swizzle_colorful(
|
||||
uint32_t v_height1 = 0;
|
||||
uint32_t v_height2 = 0;
|
||||
uint32_t v_height3 = 0;
|
||||
uint8_t v_ycc_upsampling = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
if (self->private_impl.f_swizzle_immediately) {
|
||||
@@ -57822,6 +58613,10 @@ wuffs_jpeg__decoder__swizzle_colorful(
|
||||
v_height3 = self->private_impl.f_components_workbuf_heights[3u];
|
||||
}
|
||||
}
|
||||
v_ycc_upsampling = ((uint8_t)(0u));
|
||||
if ( ! self->private_impl.f_use_lower_quality) {
|
||||
v_ycc_upsampling = ((uint8_t)(1u));
|
||||
}
|
||||
v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
|
||||
a_dst,
|
||||
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_dst_palette, 1024)),
|
||||
@@ -57854,7 +58649,7 @@ wuffs_jpeg__decoder__swizzle_colorful(
|
||||
self->private_impl.f_components_v[2u],
|
||||
self->private_impl.f_components_v[3u],
|
||||
self->private_impl.f_ycc_model,
|
||||
! self->private_impl.f_use_lower_quality,
|
||||
v_ycc_upsampling,
|
||||
wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048));
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
}
|
||||
@@ -69632,6 +70427,12 @@ wuffs_png__decoder__decode_chrm(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_cicp(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_exif(
|
||||
@@ -72177,6 +72978,25 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
}
|
||||
self->private_impl.f_seen_chrm = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1346586979u) {
|
||||
if (self->private_impl.f_report_metadata_cicp) {
|
||||
if (self->private_impl.f_seen_cicp) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_png__decoder__decode_cicp(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_seen_cicp = true;
|
||||
}
|
||||
} else if (self->private_impl.f_chunk_type == 1280598886u) {
|
||||
if (self->private_impl.f_seen_fctl) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
@@ -72185,7 +73005,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_png__decoder__decode_fctl(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -72203,7 +73023,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
status = wuffs_png__decoder__decode_gama(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -72222,7 +73042,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
status = wuffs_png__decoder__decode_iccp(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -72241,7 +73061,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
status = wuffs_png__decoder__decode_srgb(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -72260,7 +73080,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
status = wuffs_png__decoder__decode_trns(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -72274,7 +73094,7 @@ wuffs_png__decoder__decode_other_chunk(
|
||||
}
|
||||
if (self->private_impl.f_metadata_fourcc == 0u) {
|
||||
self->private_data.s_decode_other_chunk.scratch = self->private_impl.f_chunk_length;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11);
|
||||
if (self->private_data.s_decode_other_chunk.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_decode_other_chunk.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
@@ -72715,6 +73535,88 @@ wuffs_png__decoder__decode_chrm(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_cicp
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_png__decoder__decode_cicp(
|
||||
wuffs_png__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_cicp;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_chunk_length != 4u) {
|
||||
status = wuffs_base__make_status(wuffs_png__error__bad_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_chunk_length = 0u;
|
||||
self->private_impl.f_metadata_flavor = 5u;
|
||||
self->private_impl.f_metadata_fourcc = 1128874832u;
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint64_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = ((uint64_t)(wuffs_base__peek_u32le__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_decode_cicp.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_decode_cicp.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint64_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_metadata_x = t_0;
|
||||
}
|
||||
self->private_impl.f_metadata_y = 0u;
|
||||
self->private_impl.f_metadata_z = 0u;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_cicp = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_cicp = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func png.decoder.decode_exif
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -74886,6 +75788,8 @@ wuffs_png__decoder__set_report_metadata(
|
||||
|
||||
if (a_fourcc == 1128813133u) {
|
||||
self->private_impl.f_report_metadata_chrm = a_report;
|
||||
} else if (a_fourcc == 1128874832u) {
|
||||
self->private_impl.f_report_metadata_cicp = a_report;
|
||||
} else if (a_fourcc == 1163413830u) {
|
||||
self->private_impl.f_report_metadata_exif = a_report;
|
||||
} else if (a_fourcc == 1195461953u) {
|
||||
@@ -80899,7 +81803,9 @@ wuffs_thumbhash__decoder__workbuf_len(
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
const char wuffs_vp8__error__bad_quirk_source_length[] = "#vp8: bad QUIRK_SOURCE_LENGTH";
|
||||
const char wuffs_vp8__error__bad_quirk_width_and_height[] = "#vp8: bad QUIRK_WIDTH_AND_HEIGHT";
|
||||
const char wuffs_vp8__error__bad_header[] = "#vp8: bad header";
|
||||
const char wuffs_vp8__error__inconsistent_width_and_height[] = "#vp8: inconsistent width and height";
|
||||
const char wuffs_vp8__error__missing_quirk_source_length[] = "#vp8: missing QUIRK_SOURCE_LENGTH";
|
||||
const char wuffs_vp8__error__truncated_input[] = "#vp8: truncated input";
|
||||
const char wuffs_vp8__error__unsupported_quirk_source_length[] = "#vp8: unsupported QUIRK_SOURCE_LENGTH";
|
||||
@@ -81794,6 +82700,8 @@ WUFFS_VP8__ZIGZAG[16] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
9u, 12u, 13u, 10u, 7u, 11u, 14u, 15u,
|
||||
};
|
||||
|
||||
#define WUFFS_VP8__QUIRKS_BASE 1836840960u
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
@@ -81839,7 +82747,7 @@ wuffs_vp8__decoder__initialize_mb_coeffs(
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_vp8__decoder__decode_block_coefficients(
|
||||
wuffs_vp8__decoder__decode_subblock_coefficients(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
uint32_t a_mby,
|
||||
@@ -81995,7 +82903,6 @@ WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_vp8__decoder__decode_macroblocks(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -82044,11 +82951,11 @@ wuffs_vp8__decoder__copy_from_yuv_cache(
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(
|
||||
wuffs_vp8__decoder__swizzle(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
uint32_t a_mby);
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
@@ -82102,6 +83009,11 @@ wuffs_vp8__decoder__do_decode_image_config(
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_vp8__decoder__calculate_mbw_mbh(
|
||||
wuffs_vp8__decoder* self);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_vp8__decoder__do_decode_frame_config(
|
||||
@@ -82343,7 +83255,7 @@ wuffs_vp8__decoder__decode_coefficients(
|
||||
self->private_data.f_mb_states_left &= 4286578687u;
|
||||
v_tnz = (1u & (self->private_data.f_mb_states_top[a_mbx] >> 23u));
|
||||
self->private_data.f_mb_states_top[a_mbx] &= 4286578687u;
|
||||
v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self,
|
||||
v_lnz = wuffs_vp8__decoder__decode_subblock_coefficients(self,
|
||||
a_workbuf,
|
||||
a_mby,
|
||||
a_seg,
|
||||
@@ -82364,7 +83276,7 @@ wuffs_vp8__decoder__decode_coefficients(
|
||||
v_tnz = (1u & (self->private_data.f_mb_states_top[a_mbx] >> (24u + v_bx)));
|
||||
self->private_data.f_mb_states_top[a_mbx] &= (4294967295u ^ (((uint32_t)(1u)) << (24u + v_bx)));
|
||||
v_b = ((4u * v_by) + v_bx);
|
||||
v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self,
|
||||
v_lnz = wuffs_vp8__decoder__decode_subblock_coefficients(self,
|
||||
a_workbuf,
|
||||
a_mby,
|
||||
a_seg,
|
||||
@@ -82397,7 +83309,7 @@ wuffs_vp8__decoder__decode_coefficients(
|
||||
(2u * v_by) +
|
||||
v_bx +
|
||||
16u);
|
||||
v_lnz = wuffs_vp8__decoder__decode_block_coefficients(self,
|
||||
v_lnz = wuffs_vp8__decoder__decode_subblock_coefficients(self,
|
||||
a_workbuf,
|
||||
a_mby,
|
||||
a_seg,
|
||||
@@ -82445,11 +83357,11 @@ wuffs_vp8__decoder__initialize_mb_coeffs(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func vp8.decoder.decode_block_coefficients
|
||||
// -------- func vp8.decoder.decode_subblock_coefficients
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_vp8__decoder__decode_block_coefficients(
|
||||
wuffs_vp8__decoder__decode_subblock_coefficients(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
uint32_t a_mby,
|
||||
@@ -83895,11 +84807,9 @@ WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_vp8__decoder__decode_macroblocks(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__slice_u8 a_workbuf) {
|
||||
uint32_t v_mby = 0;
|
||||
uint32_t v_mbx = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
v_mbx = 0u;
|
||||
while (v_mbx < self->private_impl.f_mbw) {
|
||||
@@ -83921,24 +84831,15 @@ wuffs_vp8__decoder__decode_macroblocks(
|
||||
} else {
|
||||
wuffs_vp8__decoder__filter_normal(self, a_workbuf, (v_mby - 1u));
|
||||
}
|
||||
v_status = wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(self, a_dst, a_workbuf, (v_mby - 1u));
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
}
|
||||
}
|
||||
v_mby += 1u;
|
||||
}
|
||||
if (self->private_impl.f_mbh > 0u) {
|
||||
v_mby = (self->private_impl.f_mbh - 1u);
|
||||
if (self->private_impl.f_filt_level <= 0u) {
|
||||
} else if (self->private_impl.f_filt_simple) {
|
||||
wuffs_vp8__decoder__filter_simple(self, a_workbuf, v_mby);
|
||||
wuffs_vp8__decoder__filter_simple(self, a_workbuf, (self->private_impl.f_mbh - 1u));
|
||||
} else {
|
||||
wuffs_vp8__decoder__filter_normal(self, a_workbuf, v_mby);
|
||||
}
|
||||
v_status = wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(self, a_dst, a_workbuf, v_mby);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
wuffs_vp8__decoder__filter_normal(self, a_workbuf, (self->private_impl.f_mbh - 1u));
|
||||
}
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
@@ -84197,76 +85098,80 @@ wuffs_vp8__decoder__copy_from_yuv_cache(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func vp8.decoder.swizzle_one_row_of_macroblocks
|
||||
// -------- func vp8.decoder.swizzle
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_vp8__decoder__swizzle_one_row_of_macroblocks(
|
||||
wuffs_vp8__decoder__swizzle(
|
||||
wuffs_vp8__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
uint32_t a_mby) {
|
||||
uint32_t v_y_min_incl = 0;
|
||||
uint32_t v_y_max_excl = 0;
|
||||
uint64_t v_o = 0;
|
||||
wuffs_base__slice_u8 v_src0 = {0};
|
||||
wuffs_base__slice_u8 v_src1 = {0};
|
||||
wuffs_base__slice_u8 v_src2 = {0};
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf) {
|
||||
uint64_t v_wh = 0;
|
||||
wuffs_base__slice_u8 v_prefix = {0};
|
||||
wuffs_base__slice_u8 v_suffix = {0};
|
||||
uint32_t v_has_alpha = 0;
|
||||
uint32_t v_ycc_model = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
if ((self->private_impl.f_workbuf_yuv_y_end > self->private_impl.f_workbuf_yuv_u_end) || (self->private_impl.f_workbuf_yuv_u_end > self->private_impl.f_workbuf_yuv_v_end) || (self->private_impl.f_workbuf_yuv_v_end > ((uint64_t)(a_workbuf.len)))) {
|
||||
if (self->private_impl.f_quirk_has_alpha_side_channel) {
|
||||
if (self->private_impl.f_quirk_width_and_height == 0u) {
|
||||
return wuffs_base__make_status(wuffs_vp8__error__inconsistent_width_and_height);
|
||||
}
|
||||
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
|
||||
if (v_wh > ((uint64_t)(a_workbuf.len))) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
}
|
||||
v_prefix = wuffs_base__slice_u8__subslice_j(a_workbuf, v_wh);
|
||||
v_suffix = wuffs_base__slice_u8__subslice_i(a_workbuf, v_wh);
|
||||
v_has_alpha = 1u;
|
||||
v_ycc_model = (6u | (1u & ((uint32_t)(wuffs_base__utility__demake_pixel_blend(a_blend)))));
|
||||
} else {
|
||||
v_prefix = wuffs_base__utility__empty_slice_u8();
|
||||
v_suffix = a_workbuf;
|
||||
v_has_alpha = 0u;
|
||||
v_ycc_model = 4u;
|
||||
}
|
||||
if ((self->private_impl.f_workbuf_yuv_y_end > self->private_impl.f_workbuf_yuv_u_end) || (self->private_impl.f_workbuf_yuv_u_end > self->private_impl.f_workbuf_yuv_v_end) || (self->private_impl.f_workbuf_yuv_v_end > ((uint64_t)(v_suffix.len)))) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
}
|
||||
v_y_min_incl = wuffs_base__u32__sat_sub((a_mby * 16u), 6u);
|
||||
v_y_max_excl = ((a_mby * 16u) + 10u);
|
||||
if ((a_mby + 1u) >= self->private_impl.f_mbh) {
|
||||
v_y_max_excl = self->private_impl.f_height;
|
||||
}
|
||||
v_o = ((uint64_t)((v_y_min_incl * self->private_impl.f_workbuf_yuv_y_stride)));
|
||||
if (v_o < self->private_impl.f_workbuf_yuv_y_end) {
|
||||
v_src0 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_o, self->private_impl.f_workbuf_yuv_y_end);
|
||||
}
|
||||
v_o = (((uint64_t)(((v_y_min_incl / 2u) * self->private_impl.f_workbuf_yuv_uv_stride))) + self->private_impl.f_workbuf_yuv_y_end);
|
||||
if (v_o < self->private_impl.f_workbuf_yuv_u_end) {
|
||||
v_src1 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_o, self->private_impl.f_workbuf_yuv_u_end);
|
||||
}
|
||||
v_o = (((uint64_t)(((v_y_min_incl / 2u) * self->private_impl.f_workbuf_yuv_uv_stride))) + self->private_impl.f_workbuf_yuv_u_end);
|
||||
if (v_o < self->private_impl.f_workbuf_yuv_v_end) {
|
||||
v_src2 = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_o, self->private_impl.f_workbuf_yuv_v_end);
|
||||
}
|
||||
v_status = wuffs_base__pixel_swizzler__swizzle_ycck(&self->private_impl.f_swizzler,
|
||||
a_dst,
|
||||
wuffs_base__pixel_buffer__palette(a_dst),
|
||||
0u,
|
||||
self->private_impl.f_width,
|
||||
v_y_min_incl,
|
||||
v_y_max_excl,
|
||||
v_src0,
|
||||
v_src1,
|
||||
v_src2,
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
0u,
|
||||
self->private_impl.f_height,
|
||||
wuffs_base__slice_u8__subslice_j(v_suffix, self->private_impl.f_workbuf_yuv_y_end),
|
||||
wuffs_base__slice_u8__subslice_ij(v_suffix,
|
||||
self->private_impl.f_workbuf_yuv_y_end,
|
||||
self->private_impl.f_workbuf_yuv_u_end),
|
||||
wuffs_base__slice_u8__subslice_ij(v_suffix,
|
||||
self->private_impl.f_workbuf_yuv_u_end,
|
||||
self->private_impl.f_workbuf_yuv_v_end),
|
||||
v_prefix,
|
||||
(self->private_impl.f_mbw * 16u),
|
||||
(self->private_impl.f_mbw * 8u),
|
||||
(self->private_impl.f_mbw * 8u),
|
||||
0u,
|
||||
wuffs_base__u32__sat_sub((self->private_impl.f_mbh * 16u), v_y_min_incl),
|
||||
wuffs_base__u32__sat_sub((self->private_impl.f_mbh * 8u), (v_y_min_incl / 2u)),
|
||||
wuffs_base__u32__sat_sub((self->private_impl.f_mbh * 8u), (v_y_min_incl / 2u)),
|
||||
0u,
|
||||
(self->private_impl.f_width * v_has_alpha),
|
||||
(self->private_impl.f_mbh * 16u),
|
||||
(self->private_impl.f_mbh * 8u),
|
||||
(self->private_impl.f_mbh * 8u),
|
||||
(self->private_impl.f_height * v_has_alpha),
|
||||
(self->private_impl.f_mbw * 16u),
|
||||
(self->private_impl.f_mbw * 8u),
|
||||
(self->private_impl.f_mbw * 8u),
|
||||
0u,
|
||||
(self->private_impl.f_width * v_has_alpha),
|
||||
2u,
|
||||
1u,
|
||||
1u,
|
||||
0u,
|
||||
((uint8_t)((2u * v_has_alpha))),
|
||||
2u,
|
||||
1u,
|
||||
1u,
|
||||
0u,
|
||||
((uint8_t)(1u)),
|
||||
false,
|
||||
((uint8_t)((2u * v_has_alpha))),
|
||||
((uint8_t)(v_ycc_model)),
|
||||
((uint8_t)(2u)),
|
||||
wuffs_base__make_slice_u8(self->private_data.f_swizzle_ycck_scratch_buffer_2k, 2048));
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
}
|
||||
@@ -85185,6 +86090,12 @@ wuffs_vp8__decoder__get_quirk(
|
||||
|
||||
if (a_key == 3u) {
|
||||
return self->private_impl.f_quirk_source_length;
|
||||
} else if (a_key == 1836840960u) {
|
||||
if (self->private_impl.f_quirk_has_alpha_side_channel) {
|
||||
return 1u;
|
||||
}
|
||||
} else if (a_key == 1836840961u) {
|
||||
return self->private_impl.f_quirk_width_and_height;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
@@ -85207,8 +86118,41 @@ wuffs_vp8__decoder__set_quirk(
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
|
||||
uint32_t v_w = 0;
|
||||
uint32_t v_h = 0;
|
||||
|
||||
if (a_key == 3u) {
|
||||
self->private_impl.f_quirk_source_length = a_value;
|
||||
if ((a_value & 1u) == 0u) {
|
||||
if (a_value != 0u) {
|
||||
return wuffs_base__make_status(wuffs_vp8__error__bad_quirk_source_length);
|
||||
}
|
||||
self->private_impl.f_quirk_source_length = 0u;
|
||||
self->private_impl.f_partitioned_data_length = 0u;
|
||||
} else if ((a_value >> 1u) < 10u) {
|
||||
return wuffs_base__make_status(wuffs_vp8__error__bad_quirk_source_length);
|
||||
} else if ((a_value >> 1u) > 150994945u) {
|
||||
return wuffs_base__make_status(wuffs_vp8__error__unsupported_quirk_source_length);
|
||||
} else {
|
||||
self->private_impl.f_quirk_source_length = a_value;
|
||||
self->private_impl.f_partitioned_data_length = (((uint32_t)((a_value >> 1u))) - 10u);
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
} else if (a_key == 1836840960u) {
|
||||
self->private_impl.f_quirk_has_alpha_side_channel = (a_value != 0u);
|
||||
return wuffs_base__make_status(NULL);
|
||||
} else if (a_key == 1836840961u) {
|
||||
v_w = ((uint32_t)(a_value));
|
||||
v_h = ((uint32_t)((a_value >> 32u)));
|
||||
if ((v_w < 1u) ||
|
||||
(16383u < v_w) ||
|
||||
(v_h < 1u) ||
|
||||
(16383u < v_h)) {
|
||||
return wuffs_base__make_status(wuffs_vp8__error__bad_quirk_width_and_height);
|
||||
}
|
||||
self->private_impl.f_quirk_width_and_height = a_value;
|
||||
self->private_impl.f_width = v_w;
|
||||
self->private_impl.f_height = v_h;
|
||||
wuffs_vp8__decoder__calculate_mbw_mbh(self);
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
@@ -85311,17 +86255,10 @@ wuffs_vp8__decoder__do_decode_image_config(
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
if ((self->private_impl.f_quirk_source_length & 1u) == 0u) {
|
||||
if (self->private_impl.f_quirk_source_length == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__missing_quirk_source_length);
|
||||
goto exit;
|
||||
} else if ((self->private_impl.f_quirk_source_length >> 1u) < 10u) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__bad_quirk_source_length);
|
||||
goto exit;
|
||||
} else if ((self->private_impl.f_quirk_source_length >> 1u) > 150994945u) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__unsupported_quirk_source_length);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_partitioned_data_length = (((uint32_t)((self->private_impl.f_quirk_source_length >> 1u))) - 10u);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
@@ -85425,13 +86362,14 @@ wuffs_vp8__decoder__do_decode_image_config(
|
||||
}
|
||||
self->private_impl.f_width = (16383u & v_c32);
|
||||
self->private_impl.f_height = (16383u & (v_c32 >> 16u));
|
||||
self->private_impl.f_mbw = ((self->private_impl.f_width + 15u) / 16u);
|
||||
self->private_impl.f_mbh = ((self->private_impl.f_height + 15u) / 16u);
|
||||
self->private_impl.f_workbuf_yuv_y_stride = (self->private_impl.f_mbw * 16u);
|
||||
self->private_impl.f_workbuf_yuv_uv_stride = (self->private_impl.f_mbw * 8u);
|
||||
self->private_impl.f_workbuf_yuv_y_end = (((uint64_t)(self->private_impl.f_workbuf_yuv_y_stride)) * ((uint64_t)((self->private_impl.f_mbh * 16u))));
|
||||
self->private_impl.f_workbuf_yuv_u_end = (self->private_impl.f_workbuf_yuv_y_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
|
||||
self->private_impl.f_workbuf_yuv_v_end = (self->private_impl.f_workbuf_yuv_u_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
|
||||
if ((self->private_impl.f_width == 0u) || (self->private_impl.f_height == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__bad_header);
|
||||
goto exit;
|
||||
} else if ((self->private_impl.f_quirk_width_and_height != 0u) && (self->private_impl.f_quirk_width_and_height != (((uint64_t)(self->private_impl.f_width)) | (((uint64_t)(self->private_impl.f_height)) << 32u)))) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__inconsistent_width_and_height);
|
||||
goto exit;
|
||||
}
|
||||
wuffs_vp8__decoder__calculate_mbw_mbh(self);
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__set(
|
||||
@@ -85464,6 +86402,22 @@ wuffs_vp8__decoder__do_decode_image_config(
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func vp8.decoder.calculate_mbw_mbh
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_vp8__decoder__calculate_mbw_mbh(
|
||||
wuffs_vp8__decoder* self) {
|
||||
self->private_impl.f_mbw = ((self->private_impl.f_width + 15u) / 16u);
|
||||
self->private_impl.f_mbh = ((self->private_impl.f_height + 15u) / 16u);
|
||||
self->private_impl.f_workbuf_yuv_y_stride = (self->private_impl.f_mbw * 16u);
|
||||
self->private_impl.f_workbuf_yuv_uv_stride = (self->private_impl.f_mbw * 8u);
|
||||
self->private_impl.f_workbuf_yuv_y_end = (((uint64_t)(self->private_impl.f_workbuf_yuv_y_stride)) * ((uint64_t)((self->private_impl.f_mbh * 16u))));
|
||||
self->private_impl.f_workbuf_yuv_u_end = (self->private_impl.f_workbuf_yuv_y_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
|
||||
self->private_impl.f_workbuf_yuv_v_end = (self->private_impl.f_workbuf_yuv_u_end + (((uint64_t)(self->private_impl.f_workbuf_yuv_uv_stride)) * ((uint64_t)((self->private_impl.f_mbh * 8u)))));
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func vp8.decoder.decode_frame_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -85649,37 +86603,65 @@ wuffs_vp8__decoder__decode_frame(
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint64_t v_wh = 0;
|
||||
uint64_t v_wb_len = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
wuffs_base__slice_u8 v_trimmed = {0};
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
v_trimmed = a_workbuf;
|
||||
if (self->private_impl.f_quirk_has_alpha_side_channel) {
|
||||
if (self->private_impl.f_quirk_width_and_height == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__inconsistent_width_and_height);
|
||||
goto exit;
|
||||
}
|
||||
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
|
||||
if (v_wh > ((uint64_t)(a_workbuf.len))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_trimmed = wuffs_base__slice_u8__subslice_i(a_workbuf, v_wh);
|
||||
}
|
||||
v_wb_len = (self->private_impl.f_workbuf_yuv_v_end + ((uint64_t)(self->private_impl.f_partitioned_data_length)) + 8u);
|
||||
if (v_wb_len > ((uint64_t)(a_workbuf.len))) {
|
||||
if (v_wb_len > ((uint64_t)(v_trimmed.len))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
} else {
|
||||
a_workbuf = wuffs_base__slice_u8__subslice_j(a_workbuf, v_wb_len);
|
||||
v_trimmed = wuffs_base__slice_u8__subslice_j(v_trimmed, v_wb_len);
|
||||
}
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_vp8__decoder__do_decode_frame(self,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_blend,
|
||||
a_workbuf,
|
||||
v_trimmed,
|
||||
a_opts);
|
||||
v_status = t_0;
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_vp8__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
v_status = wuffs_vp8__decoder__swizzle(self, a_dst, a_blend, a_workbuf);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame = 0;
|
||||
@@ -85781,7 +86763,7 @@ wuffs_vp8__decoder__do_decode_frame(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_dst, a_workbuf);
|
||||
v_status = wuffs_vp8__decoder__decode_macroblocks(self, a_workbuf);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
@@ -85982,10 +86964,17 @@ wuffs_vp8__decoder__workbuf_len(
|
||||
return wuffs_base__utility__empty_range_ii_u64();
|
||||
}
|
||||
|
||||
uint64_t v_wh = 0;
|
||||
uint64_t v_wb_len = 0;
|
||||
|
||||
if (self->private_impl.f_quirk_source_length == 0u) {
|
||||
return wuffs_base__utility__make_range_ii_u64(1u, 0u);
|
||||
}
|
||||
if (self->private_impl.f_quirk_has_alpha_side_channel) {
|
||||
v_wh = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
|
||||
}
|
||||
v_wb_len = (self->private_impl.f_workbuf_yuv_v_end + ((uint64_t)(self->private_impl.f_partitioned_data_length)) + 8u);
|
||||
return wuffs_base__utility__make_range_ii_u64(v_wb_len, v_wb_len);
|
||||
return wuffs_base__utility__make_range_ii_u64((v_wh + v_wb_len), (v_wh + v_wb_len));
|
||||
}
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8)
|
||||
@@ -86916,18 +87905,20 @@ wuffs_wbmp__decoder__workbuf_len(
|
||||
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
const char wuffs_webp__error__bad_alph_vp8l_combination[] = "#webp: bad ALPH+VP8L combination";
|
||||
const char wuffs_webp__error__bad_huffman_code_over_subscribed[] = "#webp: bad Huffman code (over-subscribed)";
|
||||
const char wuffs_webp__error__bad_huffman_code_under_subscribed[] = "#webp: bad Huffman code (under-subscribed)";
|
||||
const char wuffs_webp__error__bad_huffman_code[] = "#webp: bad Huffman code";
|
||||
const char wuffs_webp__error__bad_vp8x_chunk[] = "#webp: bad VP8X chunk";
|
||||
const char wuffs_webp__error__bad_back_reference[] = "#webp: bad back-reference";
|
||||
const char wuffs_webp__error__bad_chunk_order[] = "#webp: bad chunk order";
|
||||
const char wuffs_webp__error__bad_color_cache[] = "#webp: bad color cache";
|
||||
const char wuffs_webp__error__bad_header[] = "#webp: bad header";
|
||||
const char wuffs_webp__error__bad_transform[] = "#webp: bad transform";
|
||||
const char wuffs_webp__error__short_chunk[] = "#webp: short chunk";
|
||||
const char wuffs_webp__error__truncated_input[] = "#webp: truncated input";
|
||||
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
|
||||
const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[] = "#webp: unsupported transform after color indexing transform";
|
||||
const char wuffs_webp__error__unsupported_webp_file[] = "#webp: unsupported WebP file";
|
||||
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
|
||||
const char wuffs_webp__error__internal_error_inconsistent_huffman_code[] = "#webp: internal error: inconsistent Huffman code";
|
||||
const char wuffs_webp__error__internal_error_inconsistent_dst_buffer[] = "#webp: internal error: inconsistent dst buffer";
|
||||
const char wuffs_webp__error__internal_error_inconsistent_n_bits[] = "#webp: internal error: inconsistent n_bits";
|
||||
@@ -86979,6 +87970,44 @@ WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_alph(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_alph_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__compact_alph(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__filter_alph_horizontal(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__filter_alph_vertical(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__filter_alph_gradient(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_groups(
|
||||
@@ -87042,6 +88071,7 @@ static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_predictor(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
uint32_t a_width,
|
||||
wuffs_base__slice_u8 a_tile_data);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -87072,6 +88102,7 @@ static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_cross_color(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
uint32_t a_width,
|
||||
wuffs_base__slice_u8 a_tile_data);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -87084,38 +88115,12 @@ WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix);
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
uint32_t a_width);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame(
|
||||
wuffs_webp__decoder__do_decode_frame_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
@@ -87163,6 +88168,49 @@ wuffs_webp__decoder__swizzle(
|
||||
wuffs_base__slice_u8 a_src,
|
||||
wuffs_base__pixel_blend a_blend);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8x(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts);
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
const wuffs_base__image_decoder__func_ptrs
|
||||
@@ -87279,6 +88327,375 @@ sizeof__wuffs_webp__decoder(void) {
|
||||
|
||||
// ---------------- Function Implementations
|
||||
|
||||
// -------- func webp.decoder.decode_alph
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_alph(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__slice_u8 a_workbuf) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_alph;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_sub_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_0 = wuffs_webp__decoder__decode_alph_limited(self, a_src, a_workbuf);
|
||||
v_status = t_0;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_alph = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_alph = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_alph_limited
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_alph_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__slice_u8 a_workbuf) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint64_t v_n = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_alph_limited;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint8_t t_0 = *iop_a_src++;
|
||||
self->private_impl.f_vp8x_alph_flags = t_0;
|
||||
}
|
||||
if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 3u)) == 0u) {
|
||||
wuffs_private_impl__io_reader__limited_copy_u32_to_slice(
|
||||
&iop_a_src, io2_a_src,(self->private_impl.f_width * self->private_impl.f_height), a_workbuf);
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 3u)) == 1u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_webp__decoder__do_decode_frame_vp8l(self,
|
||||
NULL,
|
||||
a_src,
|
||||
wuffs_base__utility__make_pixel_blend(0u),
|
||||
a_workbuf,
|
||||
NULL);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
v_n = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height * 4u)));
|
||||
if (v_n <= ((uint64_t)(a_workbuf.len))) {
|
||||
wuffs_webp__decoder__compact_alph(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_vp8x_alph_flags |= 2u;
|
||||
v_n = ((uint64_t)((self->private_impl.f_width * self->private_impl.f_height)));
|
||||
if (v_n <= ((uint64_t)(a_workbuf.len))) {
|
||||
if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 4u) {
|
||||
wuffs_webp__decoder__filter_alph_horizontal(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 8u) {
|
||||
wuffs_webp__decoder__filter_alph_vertical(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_alph_flags & 12u)) == 12u) {
|
||||
wuffs_webp__decoder__filter_alph_gradient(self, wuffs_base__slice_u8__subslice_j(a_workbuf, v_n));
|
||||
}
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_alph_limited = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_alph_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.compact_alph
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__compact_alph(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s) {
|
||||
uint64_t v_i = 0;
|
||||
uint64_t v_j = 0;
|
||||
|
||||
if (((uint64_t)(a_s.len)) > 1073741824u) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
v_i = 0u;
|
||||
v_j = 1u;
|
||||
while ((v_i < ((uint64_t)(a_s.len))) && (v_j < ((uint64_t)(a_s.len)))) {
|
||||
a_s.ptr[v_i] = a_s.ptr[v_j];
|
||||
v_i += 1u;
|
||||
v_j += 4u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.filter_alph_horizontal
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__filter_alph_horizontal(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s) {
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
uint64_t v_i = 0;
|
||||
uint8_t v_pred = 0;
|
||||
|
||||
v_y = 0u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_pred = 0u;
|
||||
if (v_y > 0u) {
|
||||
v_i = ((uint64_t)(((v_y - 1u) * self->private_impl.f_width)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
v_pred = a_s.ptr[v_i];
|
||||
}
|
||||
v_x = 0u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
a_s.ptr[v_i] += v_pred;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
v_pred = a_s.ptr[v_i];
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.filter_alph_vertical
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__filter_alph_vertical(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s) {
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
uint64_t v_i = 0;
|
||||
uint8_t v_pred = 0;
|
||||
|
||||
v_x = 0u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
v_pred = 0u;
|
||||
if (v_x > 0u) {
|
||||
v_i = ((uint64_t)((v_x - 1u)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
v_pred = a_s.ptr[v_i];
|
||||
}
|
||||
v_y = 0u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
a_s.ptr[v_i] += v_pred;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
v_pred = a_s.ptr[v_i];
|
||||
v_y += 1u;
|
||||
}
|
||||
v_x += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.filter_alph_gradient
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__filter_alph_gradient(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_s) {
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
uint64_t v_i = 0;
|
||||
uint8_t v_pred = 0;
|
||||
uint32_t v_grad = 0;
|
||||
uint8_t v_l = 0;
|
||||
uint8_t v_t = 0;
|
||||
uint8_t v_tl = 0;
|
||||
|
||||
v_x = 0u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
v_i = ((uint64_t)(v_x));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
a_s.ptr[v_i] += v_pred;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
v_pred = a_s.ptr[v_i];
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y = 1u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_i = ((uint64_t)(((v_y - 1u) * self->private_impl.f_width)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
v_t = a_s.ptr[v_i];
|
||||
v_tl = v_t;
|
||||
v_l = v_t;
|
||||
v_x = 0u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
v_i = ((uint64_t)((((v_y - 1u) * self->private_impl.f_width) + v_x)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
v_t = a_s.ptr[v_i];
|
||||
v_i = ((uint64_t)(((v_y * self->private_impl.f_width) + v_x)));
|
||||
if (v_i >= ((uint64_t)(a_s.len))) {
|
||||
break;
|
||||
}
|
||||
v_grad = ((uint32_t)(((uint32_t)(((uint32_t)(v_l)) + ((uint32_t)(v_t)))) - ((uint32_t)(v_tl))));
|
||||
if (v_grad > 2147483647u) {
|
||||
v_grad = 0u;
|
||||
} else if (v_grad > 255u) {
|
||||
v_grad = 255u;
|
||||
}
|
||||
v_l = ((uint8_t)(a_s.ptr[v_i] + ((uint8_t)(v_grad))));
|
||||
a_s.ptr[v_i] = v_l;
|
||||
v_tl = v_t;
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_huffman_groups
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -88463,6 +89880,7 @@ static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_predictor(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
uint32_t a_width,
|
||||
wuffs_base__slice_u8 a_tile_data) {
|
||||
uint64_t v_w4 = 0;
|
||||
wuffs_base__slice_u8 v_prev_row = {0};
|
||||
@@ -88490,10 +89908,10 @@ wuffs_webp__decoder__apply_transform_predictor(
|
||||
uint32_t v_sum_l = 0;
|
||||
uint32_t v_sum_t = 0;
|
||||
|
||||
if ((self->private_impl.f_width <= 0u) || (self->private_impl.f_height <= 0u)) {
|
||||
if ((a_width <= 0u) || (self->private_impl.f_height <= 0u)) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
v_w4 = ((uint64_t)((self->private_impl.f_width * 4u)));
|
||||
v_w4 = ((uint64_t)((a_width * 4u)));
|
||||
v_curr_row = wuffs_base__utility__empty_slice_u8();
|
||||
if (v_w4 <= ((uint64_t)(a_pix.len))) {
|
||||
v_curr_row = wuffs_base__slice_u8__subslice_j(a_pix, v_w4);
|
||||
@@ -88523,7 +89941,7 @@ wuffs_webp__decoder__apply_transform_predictor(
|
||||
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
|
||||
}
|
||||
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[0u]));
|
||||
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
v_tiles_per_row = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
|
||||
v_y = 1u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
@@ -88555,7 +89973,7 @@ wuffs_webp__decoder__apply_transform_predictor(
|
||||
#endif
|
||||
}
|
||||
v_x = 1u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < a_width) {
|
||||
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
|
||||
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
|
||||
@@ -88851,6 +90269,7 @@ static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_cross_color(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
uint32_t a_width,
|
||||
wuffs_base__slice_u8 a_tile_data) {
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_tiles_per_row = 0;
|
||||
@@ -88867,7 +90286,7 @@ wuffs_webp__decoder__apply_transform_cross_color(
|
||||
uint8_t v_r = 0;
|
||||
|
||||
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[1u]));
|
||||
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
v_tiles_per_row = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
|
||||
v_y = 0u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
@@ -88877,7 +90296,7 @@ wuffs_webp__decoder__apply_transform_cross_color(
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
|
||||
}
|
||||
v_x = 0u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
while (v_x < a_width) {
|
||||
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
|
||||
v_g2r = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[0u]);
|
||||
v_g2b = wuffs_base__utility__sign_extend_convert_u8_u32(v_tile_data.ptr[1u]);
|
||||
@@ -88948,7 +90367,8 @@ WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix) {
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
uint32_t a_width) {
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_bits_per_pixel = 0;
|
||||
uint32_t v_x_mask = 0;
|
||||
@@ -88995,8 +90415,8 @@ wuffs_webp__decoder__apply_transform_color_indexing(
|
||||
v_src_index = ((uint64_t)((self->private_impl.f_workbuf_offset_for_color_indexing + 1u)));
|
||||
v_y = 0u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_di = ((uint64_t)((4u * v_y * self->private_impl.f_width)));
|
||||
v_dj = ((uint64_t)((4u * (v_y + 1u) * self->private_impl.f_width)));
|
||||
v_di = ((uint64_t)((4u * v_y * a_width)));
|
||||
v_dj = ((uint64_t)((4u * (v_y + 1u) * a_width)));
|
||||
if ((v_di > v_dj) || (v_dj > ((uint64_t)(a_pix.len)))) {
|
||||
break;
|
||||
}
|
||||
@@ -89025,866 +90445,11 @@ wuffs_webp__decoder__apply_transform_color_indexing(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.get_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC uint64_t
|
||||
wuffs_webp__decoder__get_quirk(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint32_t a_key) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0u;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.set_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__set_quirk(
|
||||
wuffs_webp__decoder* self,
|
||||
uint32_t a_key,
|
||||
uint64_t a_value) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_image_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__decode_image_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
if (!a_src) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
if ((self->private_impl.active_coroutine != 0) &&
|
||||
(self->private_impl.active_coroutine != 1)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
|
||||
}
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_image_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_image_config(self, a_dst, a_src);
|
||||
v_status = t_0;
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_image_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config
|
||||
// -------- func webp.decoder.do_decode_frame_vp8l
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 1179011410u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_riff_chunk_length = t_1;
|
||||
}
|
||||
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_riff_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_dst, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_riff_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_riff_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if ( ! self->private_impl.f_is_vp8_lossy && (a_dst != NULL)) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
self->private_impl.f_pixfmt,
|
||||
0u,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
false);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 32u;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 1346520407u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
if (v_c32 == 540561494u) {
|
||||
self->private_impl.f_is_vp8_lossy = true;
|
||||
} else if (v_c32 == 1278758998u) {
|
||||
} else if (v_c32 == 1480085590u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_2)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_sub_chunk_length = t_2;
|
||||
}
|
||||
if (self->private_impl.f_sub_chunk_length < 4u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_sub_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_3 = wuffs_vp8__decoder__decode_image_config(&self->private_data.f_vp8, a_dst, a_src);
|
||||
v_status = t_3;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_4 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
|
||||
v_status = t_4;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint32_t v_transform_size = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_0 = *iop_a_src++;
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 47u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
|
||||
v_c32 >>= 14u;
|
||||
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
|
||||
v_c32 >>= 14u;
|
||||
self->private_impl.f_pixfmt = 2415954056u;
|
||||
if ((v_c32 & 1u) != 0u) {
|
||||
self->private_impl.f_pixfmt = 2164295816u;
|
||||
}
|
||||
v_c32 >>= 1u;
|
||||
if (v_c32 != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
|
||||
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + 0u);
|
||||
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
|
||||
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
|
||||
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_frame_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__decode_frame_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
if (!a_src) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
if ((self->private_impl.active_coroutine != 0) &&
|
||||
(self->private_impl.active_coroutine != 2)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
|
||||
}
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_vp8__decoder__decode_frame_config(&self->private_data.f_vp8, a_dst, a_src);
|
||||
v_status = t_0;
|
||||
}
|
||||
} else {
|
||||
{
|
||||
wuffs_base__status t_1 = wuffs_webp__decoder__do_decode_frame_config(self, a_dst, a_src);
|
||||
v_status = t_1;
|
||||
}
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_frame_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__pixel_format v_pixfmt = {0};
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence == 32u) {
|
||||
} else if (self->private_impl.f_call_sequence < 32u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__do_decode_image_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 40u) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 64u) {
|
||||
self->private_impl.f_call_sequence = 96u;
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
if (a_dst != NULL) {
|
||||
v_pixfmt = wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt);
|
||||
wuffs_base__frame_config__set(
|
||||
a_dst,
|
||||
wuffs_base__utility__make_rect_ie_u32(
|
||||
0u,
|
||||
0u,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height),
|
||||
((wuffs_base__flicks)(0u)),
|
||||
0u,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
0u,
|
||||
false,
|
||||
false,
|
||||
wuffs_base__pixel_format__default_background_color(&v_pixfmt));
|
||||
}
|
||||
self->private_impl.f_call_sequence = 64u;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_frame_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_frame
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__decode_frame(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
if (!a_dst || !a_src) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
if ((self->private_impl.active_coroutine != 0) &&
|
||||
(self->private_impl.active_coroutine != 3)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
|
||||
}
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_vp8__decoder__decode_frame(&self->private_data.f_vp8,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_blend,
|
||||
a_workbuf,
|
||||
a_opts);
|
||||
v_status = t_0;
|
||||
}
|
||||
} else {
|
||||
{
|
||||
wuffs_base__status t_1 = wuffs_webp__decoder__do_decode_frame(self,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_blend,
|
||||
a_workbuf,
|
||||
a_opts);
|
||||
v_status = t_1;
|
||||
}
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_frame
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame(
|
||||
wuffs_webp__decoder__do_decode_frame_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
@@ -89916,30 +90481,13 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_vp8l;
|
||||
if (coro_susp_point) {
|
||||
v_width = self->private_data.s_do_decode_frame.v_width;
|
||||
v_width = self->private_data.s_do_decode_frame_vp8l.v_width;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence == 64u) {
|
||||
} else if (self->private_impl.f_call_sequence < 64u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
self->private_impl.f_seen_transform[0u] = false;
|
||||
self->private_impl.f_seen_transform[1u] = false;
|
||||
self->private_impl.f_seen_transform[2u] = false;
|
||||
@@ -89948,7 +90496,7 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
while (true) {
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
@@ -89968,7 +90516,7 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -89984,7 +90532,7 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -89996,7 +90544,7 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -90008,7 +90556,7 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
@@ -90017,10 +90565,7 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
goto suspend;
|
||||
}
|
||||
while (true) {
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) ||
|
||||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) ||
|
||||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len))) ||
|
||||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
@@ -90050,13 +90595,18 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6);
|
||||
}
|
||||
if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
|
||||
v_width = self->private_impl.f_width;
|
||||
if (self->private_impl.f_seen_transform[3u] && (((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) <= ((uint64_t)(v_pix.len)))) {
|
||||
v_pix = wuffs_base__slice_u8__subslice_i(v_pix, ((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)));
|
||||
v_width = self->private_impl.f_color_indexing_width;
|
||||
}
|
||||
v_which = self->private_impl.f_n_transforms;
|
||||
while (v_which > 0u) {
|
||||
v_which -= 1u;
|
||||
@@ -90070,14 +90620,15 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
}
|
||||
}
|
||||
if (v_transform_type == 0u) {
|
||||
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_tile_data);
|
||||
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_width, v_tile_data);
|
||||
} else if (v_transform_type == 1u) {
|
||||
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_tile_data);
|
||||
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_width, v_tile_data);
|
||||
} else if (v_transform_type == 2u) {
|
||||
wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix);
|
||||
} else {
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix);
|
||||
} else if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) <= ((uint64_t)(a_workbuf.len))) {
|
||||
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
|
||||
v_width = self->private_impl.f_width;
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix, v_width);
|
||||
}
|
||||
}
|
||||
v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, a_blend);
|
||||
@@ -90094,14 +90645,14 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
self->private_impl.f_call_sequence = 96u;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_frame = 0;
|
||||
self->private_impl.p_do_decode_frame_vp8l = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_do_decode_frame.v_width = v_width;
|
||||
self->private_impl.p_do_decode_frame_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_do_decode_frame_vp8l.v_width = v_width;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
@@ -90126,6 +90677,7 @@ wuffs_webp__decoder__decode_transform(
|
||||
uint8_t v_c8 = 0;
|
||||
uint32_t v_transform_type = 0;
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_width = 0;
|
||||
wuffs_base__slice_u8 v_p = {0};
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
@@ -90170,9 +90722,6 @@ wuffs_webp__decoder__decode_transform(
|
||||
if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_transform);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_seen_transform[3u]) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_transform_after_color_indexing_transform);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_seen_transform[v_transform_type] = true;
|
||||
self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type));
|
||||
@@ -90222,6 +90771,10 @@ wuffs_webp__decoder__decode_transform(
|
||||
goto suspend;
|
||||
}
|
||||
while (true) {
|
||||
v_width = self->private_impl.f_width;
|
||||
if (self->private_impl.f_seen_transform[3u]) {
|
||||
v_width = self->private_impl.f_color_indexing_width;
|
||||
}
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
@@ -90235,7 +90788,7 @@ wuffs_webp__decoder__decode_transform(
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
|
||||
a_src,
|
||||
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
((v_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
0u);
|
||||
@@ -90721,10 +91274,13 @@ wuffs_webp__decoder__swizzle(
|
||||
wuffs_base__slice_u8 v_dst = {0};
|
||||
uint32_t v_y = 0;
|
||||
|
||||
if (a_dst == NULL) {
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
|
||||
wuffs_base__pixel_buffer__pixel_format(a_dst),
|
||||
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)),
|
||||
wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt),
|
||||
wuffs_base__utility__make_pixel_format(2164295816u),
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
a_blend);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
@@ -90752,6 +91308,1308 @@ wuffs_webp__decoder__swizzle(
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.get_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC uint64_t
|
||||
wuffs_webp__decoder__get_quirk(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint32_t a_key) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0u;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.set_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__set_quirk(
|
||||
wuffs_webp__decoder* self,
|
||||
uint32_t a_key,
|
||||
uint64_t a_value) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_image_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__decode_image_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
if (!a_src) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
if ((self->private_impl.active_coroutine != 0) &&
|
||||
(self->private_impl.active_coroutine != 1)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
|
||||
}
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_image_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_image_config(self, a_dst, a_src);
|
||||
v_status = t_0;
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_image_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 1 : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 1179011410u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_riff_chunk_length = t_1;
|
||||
}
|
||||
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_rcl_remaining = self->private_impl.f_riff_chunk_length;
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_rcl_remaining)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_dst, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_rcl_remaining, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_rcl_remaining == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if ((self->private_impl.f_variant != 1u) && (a_dst != NULL)) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
2164295816u,
|
||||
0u,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
false);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 32u;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 1346520407u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
if (v_c32 == 540561494u) {
|
||||
self->private_impl.f_variant = 1u;
|
||||
} else if (v_c32 == 1278758998u) {
|
||||
self->private_impl.f_variant = 2u;
|
||||
} else if (v_c32 == 1480085590u) {
|
||||
self->private_impl.f_variant = 4u;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_2)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_sub_chunk_length = t_2;
|
||||
}
|
||||
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
|
||||
} else if (self->private_impl.f_variant == 2u) {
|
||||
} else if (self->private_impl.f_sub_chunk_length != 10u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_sub_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_3 = wuffs_vp8__decoder__decode_image_config(&self->private_data.f_vp8, a_dst, a_src);
|
||||
v_status = t_3;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
} else if (self->private_impl.f_variant == 2u) {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_4 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
|
||||
v_status = t_4;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_5 = wuffs_webp__decoder__do_decode_image_config_limited_vp8x(self, a_src);
|
||||
v_status = t_5;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint32_t v_transform_size = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_0 = *iop_a_src++;
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 47u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
|
||||
v_c32 >>= 14u;
|
||||
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
|
||||
v_c32 >>= 14u;
|
||||
v_c32 >>= 1u;
|
||||
if (v_c32 != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
|
||||
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + 0u);
|
||||
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
|
||||
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
|
||||
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited_vp8x
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8x(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint32_t v_transform_size = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8x;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited_vp8x.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8x.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if ((v_c32 & 4294967233u) != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_vp8x_header_flags = ((uint8_t)((v_c32 | 1u)));
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) {
|
||||
t_1 = ((uint32_t)(wuffs_base__peek_u24le__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 3;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited_vp8x.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8x.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 16) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
if (v_c32 >= 16383u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) {
|
||||
t_2 = ((uint32_t)(wuffs_base__peek_u24le__no_bounds_check(iop_a_src)));
|
||||
iop_a_src += 3;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited_vp8x.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8x.scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
|
||||
if (num_bits_2 == 16) {
|
||||
t_2 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_2)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_2;
|
||||
}
|
||||
if (v_c32 >= 16383u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
|
||||
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
|
||||
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + 0u);
|
||||
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + v_transform_size);
|
||||
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
|
||||
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
|
||||
v_status = wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_riff_chunk_length)) << 1u) | 1u));
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
}
|
||||
v_status = wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840961u, (((uint64_t)(self->private_impl.f_width)) | (((uint64_t)(self->private_impl.f_height)) << 32u)));
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8x = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8x = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_frame_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__decode_frame_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
if (!a_src) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
if ((self->private_impl.active_coroutine != 0) &&
|
||||
(self->private_impl.active_coroutine != 2)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
|
||||
}
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_vp8__decoder__decode_frame_config(&self->private_data.f_vp8, a_dst, a_src);
|
||||
v_status = t_0;
|
||||
}
|
||||
} else {
|
||||
{
|
||||
wuffs_base__status t_1 = wuffs_webp__decoder__do_decode_frame_config(self, a_dst, a_src);
|
||||
v_status = t_1;
|
||||
}
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 2 : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_frame_config
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame_config(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__frame_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence == 32u) {
|
||||
} else if (self->private_impl.f_call_sequence < 32u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__do_decode_image_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 40u) {
|
||||
if (self->private_impl.f_frame_config_io_position != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_restart);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_call_sequence == 64u) {
|
||||
self->private_impl.f_call_sequence = 96u;
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
if ((self->private_impl.f_variant != 1u) && (a_dst != NULL)) {
|
||||
wuffs_base__frame_config__set(
|
||||
a_dst,
|
||||
wuffs_base__utility__make_rect_ie_u32(
|
||||
0u,
|
||||
0u,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height),
|
||||
((wuffs_base__flicks)(0u)),
|
||||
0u,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
0u,
|
||||
false,
|
||||
false,
|
||||
0u);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 64u;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_frame_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_frame_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_frame
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_webp__decoder__decode_frame(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
if (!a_dst || !a_src) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_argument);
|
||||
}
|
||||
if ((self->private_impl.active_coroutine != 0) &&
|
||||
(self->private_impl.active_coroutine != 3)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
return wuffs_base__make_status(wuffs_base__error__interleaved_coroutine_calls);
|
||||
}
|
||||
self->private_impl.active_coroutine = 0;
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_frame;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
while (true) {
|
||||
{
|
||||
wuffs_base__status t_0 = wuffs_webp__decoder__do_decode_frame(self,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_blend,
|
||||
a_workbuf,
|
||||
a_opts);
|
||||
v_status = t_0;
|
||||
}
|
||||
if ((v_status.repr == wuffs_base__suspension__short_read) && (a_src && a_src->meta.closed)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__truncated_input);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(1);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_frame = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_impl.active_coroutine = wuffs_base__status__is_suspension(&status) ? 3 : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
self->private_impl.magic = WUFFS_BASE__DISABLED;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_frame
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__pixel_blend a_blend,
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence == 64u) {
|
||||
} else if (self->private_impl.f_call_sequence < 64u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
while (((uint8_t)(self->private_impl.f_variant & 3u)) == 0u) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_frame.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_frame.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_sub_chunk_type = t_0;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_frame.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_frame.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_sub_chunk_length = t_1;
|
||||
}
|
||||
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
|
||||
if (self->private_impl.f_sub_chunk_length > 2147483647u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_sub_chunk_type == 1346585417u) {
|
||||
if (self->private_impl.f_variant > 4u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
|
||||
goto exit;
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 32u)) == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_variant = 8u;
|
||||
} else if (self->private_impl.f_sub_chunk_type == 1296649793u) {
|
||||
if (self->private_impl.f_variant > 8u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
|
||||
goto exit;
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 2u)) == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_variant = 16u;
|
||||
} else if (self->private_impl.f_sub_chunk_type == 1179471425u) {
|
||||
if (self->private_impl.f_variant > 16u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
|
||||
goto exit;
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 2u)) == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_variant = 32u;
|
||||
} else if (self->private_impl.f_sub_chunk_type == 1213221953u) {
|
||||
if (self->private_impl.f_variant > 32u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_chunk_order);
|
||||
goto exit;
|
||||
} else if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 16u)) == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_variant = 64u;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_webp__decoder__decode_alph(self, a_src, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 1836840960u, 1u);
|
||||
} else if (self->private_impl.f_sub_chunk_type == 540561494u) {
|
||||
wuffs_vp8__decoder__set_quirk(&self->private_data.f_vp8, 3u, ((((uint64_t)(self->private_impl.f_sub_chunk_length)) << 1u) | 1u));
|
||||
self->private_impl.f_variant = 129u;
|
||||
break;
|
||||
} else if (self->private_impl.f_sub_chunk_type == 1278758998u) {
|
||||
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 16u)) != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_alph_vp8l_combination);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_variant = 130u;
|
||||
break;
|
||||
} else if (self->private_impl.f_sub_chunk_type == 542133592u) {
|
||||
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 4u)) == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
} else if (self->private_impl.f_sub_chunk_type == 1179211845u) {
|
||||
if (((uint8_t)(self->private_impl.f_vp8x_header_flags & 8u)) == 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_vp8x_chunk);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
self->private_data.s_do_decode_frame.scratch = self->private_impl.f_sub_chunk_length;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
if (self->private_data.s_do_decode_frame.scratch > ((uint64_t)(io2_a_src - iop_a_src))) {
|
||||
self->private_data.s_do_decode_frame.scratch -= ((uint64_t)(io2_a_src - iop_a_src));
|
||||
iop_a_src = io2_a_src;
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src += self->private_data.s_do_decode_frame.scratch;
|
||||
if (self->private_impl.f_sub_chunk_has_padding) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
iop_a_src++;
|
||||
}
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_sub_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
if (((uint8_t)(self->private_impl.f_variant & 1u)) != 0u) {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_vp8__decoder__decode_frame(&self->private_data.f_vp8,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_blend,
|
||||
a_workbuf,
|
||||
a_opts);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_frame_vp8l(self,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_blend,
|
||||
a_workbuf,
|
||||
a_opts);
|
||||
v_status = t_3;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(9);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_frame = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_frame = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.frame_dirty_rect
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -90766,7 +92624,7 @@ wuffs_webp__decoder__frame_dirty_rect(
|
||||
return wuffs_base__utility__empty_rect_ie_u32();
|
||||
}
|
||||
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
return wuffs_vp8__decoder__frame_dirty_rect(&self->private_data.f_vp8);
|
||||
}
|
||||
return wuffs_base__utility__make_rect_ie_u32(
|
||||
@@ -90807,7 +92665,7 @@ wuffs_webp__decoder__num_decoded_frame_configs(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
return wuffs_vp8__decoder__num_decoded_frame_configs(&self->private_data.f_vp8);
|
||||
}
|
||||
if (self->private_impl.f_call_sequence > 32u) {
|
||||
@@ -90830,7 +92688,7 @@ wuffs_webp__decoder__num_decoded_frames(
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
return wuffs_vp8__decoder__num_decoded_frames(&self->private_data.f_vp8);
|
||||
}
|
||||
if (self->private_impl.f_call_sequence > 64u) {
|
||||
@@ -90859,7 +92717,7 @@ wuffs_webp__decoder__restart_frame(
|
||||
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
v_status = wuffs_vp8__decoder__restart_frame(&self->private_data.f_vp8, a_index, a_io_position);
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
}
|
||||
@@ -90941,10 +92799,21 @@ wuffs_webp__decoder__workbuf_len(
|
||||
return wuffs_base__utility__empty_range_ii_u64();
|
||||
}
|
||||
|
||||
if (self->private_impl.f_is_vp8_lossy) {
|
||||
wuffs_base__range_ii_u64 v_r = {0};
|
||||
wuffs_base__range_ii_u64 v_s = {0};
|
||||
|
||||
if (self->private_impl.f_variant == 1u) {
|
||||
return wuffs_vp8__decoder__workbuf_len(&self->private_data.f_vp8);
|
||||
}
|
||||
return wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
|
||||
v_r = wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
|
||||
if (self->private_impl.f_variant != 2u) {
|
||||
v_s = wuffs_vp8__decoder__workbuf_len(&self->private_data.f_vp8);
|
||||
if (wuffs_base__range_ii_u64__is_empty(&v_s)) {
|
||||
return v_s;
|
||||
}
|
||||
v_r = wuffs_base__utility__make_range_ii_u64(wuffs_base__u64__max(wuffs_private_impl__range_ii_u64__get_min_incl(&v_s), wuffs_private_impl__range_ii_u64__get_min_incl(&v_r)), wuffs_base__u64__max(wuffs_private_impl__range_ii_u64__get_max_incl(&v_s), wuffs_private_impl__range_ii_u64__get_max_incl(&v_r)));
|
||||
}
|
||||
return v_r;
|
||||
}
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
|
||||
@@ -95406,6 +97275,9 @@ redirect:
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_CHRM) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CHRM, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_CICP) {
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__CICP, true);
|
||||
}
|
||||
if (flags & DecodeImageArgFlags::REPORT_METADATA_EXIF) {
|
||||
interested_in_metadata_after_the_frame = true;
|
||||
image_decoder->set_report_metadata(WUFFS_BASE__FOURCC__EXIF, true);
|
||||
@@ -95499,8 +97371,9 @@ redirect:
|
||||
}
|
||||
wuffs_base__pixel_buffer pixel_buffer = alloc_pixbuf_result.pixbuf;
|
||||
if (valid_background_color) {
|
||||
wuffs_base__status pb_scufr_status = pixel_buffer.set_color_u32_fill_rect(
|
||||
pixel_buffer.pixcfg.bounds(), background_color);
|
||||
wuffs_base__status pb_scufr_status =
|
||||
pixel_buffer.set_color_u32_argb_premul_fill_rect(
|
||||
pixel_buffer.pixcfg.bounds(), background_color);
|
||||
if (pb_scufr_status.repr != nullptr) {
|
||||
return DecodeImageResult(pb_scufr_status.message());
|
||||
}
|
||||
@@ -95509,6 +97382,9 @@ redirect:
|
||||
// Allocate the work buffer. Wuffs' decoders conventionally assume that this
|
||||
// can be uninitialized memory.
|
||||
wuffs_base__range_ii_u64 workbuf_len = image_decoder->workbuf_len();
|
||||
if (workbuf_len.is_empty()) {
|
||||
return DecodeImageResult(DecodeImage_UnsupportedImageFormat);
|
||||
}
|
||||
DecodeImageCallbacks::AllocWorkbufResult alloc_workbuf_result =
|
||||
callbacks.AllocWorkbuf(workbuf_len, true);
|
||||
if (!alloc_workbuf_result.error_message.empty()) {
|
||||
@@ -96449,7 +98325,12 @@ wuffs_drop_in__stb__load1( //
|
||||
}
|
||||
|
||||
uint64_t pixbuf_len = (uint64_t)w * (uint64_t)h * (uint64_t)desired_channels;
|
||||
uint64_t workbuf_len = wuffs_base__image_decoder__workbuf_len(dec).max_incl;
|
||||
wuffs_base__range_ii_u64 r = wuffs_base__image_decoder__workbuf_len(dec);
|
||||
if (wuffs_base__range_ii_u64__is_empty(&r)) {
|
||||
wuffs_drop_in__stb__g_failure_reason = "indeterminate workbuf length";
|
||||
return NULL;
|
||||
}
|
||||
uint64_t workbuf_len = r.max_incl;
|
||||
#if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull
|
||||
if ((pixbuf_len > ((uint64_t)SIZE_MAX)) ||
|
||||
(workbuf_len > ((uint64_t)SIZE_MAX))) {
|
||||
|
||||
Reference in new issue
Block a user