Run script/sync.sh: 0.4.0-alpha.9+3837.20240914
diff --git a/release/c/wuffs-v0.4.c b/release/c/wuffs-v0.4.c index 0c6616a..014b129 100644 --- a/release/c/wuffs-v0.4.c +++ b/release/c/wuffs-v0.4.c
@@ -81,15 +81,15 @@ // each major.minor branch, the commit count should increase monotonically. // // WUFFS_VERSION was overridden by "wuffs gen -version" based on revision -// 5d69840f8e7ca481551b02c7e8d4c5fb69521bb9 committed on 2024-08-12. +// a14745aa458fd2b2785034efa04eab3c7b5b91e0 committed on 2024-09-14. #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.8" -#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3796 -#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240812 -#define WUFFS_VERSION_STRING "0.4.0-alpha.8+3796.20240812" +#define WUFFS_VERSION_PRE_RELEASE_LABEL "alpha.9" +#define WUFFS_VERSION_BUILD_METADATA_COMMIT_COUNT 3837 +#define WUFFS_VERSION_BUILD_METADATA_COMMIT_DATE 20240914 +#define WUFFS_VERSION_STRING "0.4.0-alpha.9+3837.20240914" // ---------------- Private Implementation Macros Re-definition Check @@ -119,6 +119,20 @@ #endif +// ---------------- Obsolete Macros Check + +// std/tga was renamed to std/targa in September 2024 (Wuffs v0.4 alpha). +#if defined(WUFFS_CONFIG__MODULE__TGA) + +#if defined(__GNUC__) || defined(__clang__) +#warning "WUFFS_CONFIG__MODULE__TGA was renamed to WUFFS_CONFIG__MODULE__TARGA" +#elif defined(_MSC_VER) +#pragma message( \ + "WUFFS_CONFIG__MODULE__TGA was renamed to WUFFS_CONFIG__MODULE__TARGA") +#endif + +#endif + // ---------------- Configuration // Define WUFFS_CONFIG__AVOID_CPU_ARCH to avoid any code tied to a specific CPU @@ -755,6 +769,12 @@ // Wuffs' u32 values are big-endian ("JPEG" is 0x4A504547 not 0x4745504A) to // preserve ordering: "JPEG" < "MP3 " and 0x4A504547 < 0x4D503320. +// Android Binary XML (for resources; see AndroidBinXmlParser.java). +#define WUFFS_BASE__FOURCC__ABXR 0x41425852 + +// Android Binary XML (for system_server; see BinaryXmlSerializer.java). +#define WUFFS_BASE__FOURCC__ABXS 0x41425853 + // Background Color. #define WUFFS_BASE__FOURCC__BGCL 0x4247434C @@ -779,6 +799,9 @@ // Encapsulated PostScript. #define WUFFS_BASE__FOURCC__EPS 0x45505320 +// Ericsson Texture Compression 2 (iPACKMAN). +#define WUFFS_BASE__FOURCC__ETC2 0x45544332 + // Exchangeable Image File Format. #define WUFFS_BASE__FOURCC__EXIF 0x45584946 @@ -908,6 +931,9 @@ // Truevision Advanced Raster Graphics Adapter. #define WUFFS_BASE__FOURCC__TGA 0x54474120 +// Thumbhash. +#define WUFFS_BASE__FOURCC__TH 0x54482020 + // Tagged Image File Format. #define WUFFS_BASE__FOURCC__TIFF 0x54494646 @@ -4213,6 +4239,46 @@ return (a16 << 48) | (r16 << 32) | (g16 << 16) | (b16 << 0); } +static inline uint8_t // +wuffs_base__color_u64_argb_premul__as__color_u8_gray(uint64_t argb_premul) { + uint32_t r16 = ((uint32_t)(0xFFFF & (argb_premul >> 32))); + uint32_t g16 = ((uint32_t)(0xFFFF & (argb_premul >> 16))); + uint32_t b16 = ((uint32_t)(0xFFFF & (argb_premul >> 0))); + + // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same + // as those given by the JFIF specification. + // + // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We + // shift by 24, not just by 16, because the return value is 8-bit color, not + // 16-bit color. + uint32_t weighted_average = + (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; + return (uint8_t)(weighted_average >> 24); +} + +static inline uint8_t // +wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray( + uint64_t argb_nonpremul) { + uint32_t a16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 48))); + + uint32_t r16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 32))); + r16 = (r16 * a16) / 0xFFFF; + uint32_t g16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 16))); + g16 = (g16 * a16) / 0xFFFF; + uint32_t b16 = ((uint32_t)(0xFFFF & (argb_nonpremul >> 0))); + b16 = (b16 * a16) / 0xFFFF; + + // These coefficients (the fractions 0.299, 0.587 and 0.114) are the same + // as those given by the JFIF specification. + // + // Note that 19595 + 38470 + 7471 equals 65536, also known as (1 << 16). We + // shift by 24, not just by 16, because the return value is 8-bit color, not + // 16-bit color. + uint32_t weighted_average = + (19595 * r16) + (38470 * g16) + (7471 * b16) + 32768; + return (uint8_t)(weighted_average >> 24); +} + static inline uint64_t // wuffs_base__color_u32__as__color_u64(uint32_t c) { uint64_t a16 = 0x101 * (0xFF & (c >> 24)); @@ -4335,6 +4401,20 @@ // -------- +// wuffs_base__pixel_coloration is whether a pixel format's color model has no +// color (alpha only), gray color or rich (non-gray) color. Rich color includes +// RGB, BGR, YCC, YCCK, CMY and CMYK. +// +// Coloration does not capture the alpha aspect of the color model. It does not +// distinguish RGB from RGBA. +typedef uint32_t wuffs_base__pixel_coloration; + +#define WUFFS_BASE__PIXEL_COLORATION__NONE 0 +#define WUFFS_BASE__PIXEL_COLORATION__GRAY 1 +#define WUFFS_BASE__PIXEL_COLORATION__RICH 3 + +// -------- + // Deprecated: use WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX_INCL. #define WUFFS_BASE__PIXEL_FORMAT__NUM_PLANES_MAX 4 @@ -4363,6 +4443,7 @@ inline bool is_indexed() const; inline bool is_interleaved() const; inline bool is_planar() const; + inline uint32_t coloration() const; inline uint32_t num_planes() const; inline wuffs_base__pixel_alpha_transparency transparency() const; #endif // __cplusplus @@ -4470,6 +4551,12 @@ } static inline uint32_t // +wuffs_base__pixel_format__coloration(const wuffs_base__pixel_format* f) { + uint32_t n = (f->repr) >> 29; + return (n <= 1) ? n : 3; +} + +static inline uint32_t // wuffs_base__pixel_format__num_planes(const wuffs_base__pixel_format* f) { return ((f->repr >> 16) & 0x03) + 1; } @@ -4512,6 +4599,11 @@ } inline uint32_t // +wuffs_base__pixel_format::coloration() const { + return wuffs_base__pixel_format__coloration(this); +} + +inline uint32_t // wuffs_base__pixel_format::num_planes() const { return wuffs_base__pixel_format__num_planes(this); } @@ -7963,7 +8055,7 @@ #define WUFFS_CBOR__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 9u -#define WUFFS_CBOR__TOKEN_VALUE_MAJOR 787997u +#define WUFFS_CBOR__TOKEN_VALUE_MAJOR 731642u #define WUFFS_CBOR__TOKEN_VALUE_MINOR__DETAIL_MASK 262143u @@ -8936,6 +9028,372 @@ #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__DEFLATE) || defined(WUFFS_NONMONOLITHIC) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) || defined(WUFFS_NONMONOLITHIC) + +// ---------------- Status Codes + +extern const char wuffs_etc2__error__bad_header[]; +extern const char wuffs_etc2__error__truncated_input[]; +extern const char wuffs_etc2__error__unsupported_etc2_file[]; + +// ---------------- Public Consts + +#define WUFFS_ETC2__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u + +// ---------------- Struct Declarations + +typedef struct wuffs_etc2__decoder__struct wuffs_etc2__decoder; + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Public Initializer Prototypes + +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". +// +// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT +wuffs_etc2__decoder__initialize( + wuffs_etc2__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options); + +size_t +sizeof__wuffs_etc2__decoder(void); + +// ---------------- Allocs + +// These functions allocate and initialize Wuffs structs. They return NULL if +// memory allocation fails. If they return non-NULL, there is no need to call +// wuffs_foo__bar__initialize, but the caller is responsible for eventually +// calling free on the returned pointer. That pointer is effectively a C++ +// std::unique_ptr<T, wuffs_unique_ptr_deleter>. + +wuffs_etc2__decoder* +wuffs_etc2__decoder__alloc(void); + +static inline wuffs_base__image_decoder* +wuffs_etc2__decoder__alloc_as__wuffs_base__image_decoder(void) { + return (wuffs_base__image_decoder*)(wuffs_etc2__decoder__alloc()); +} + +// ---------------- Upcasts + +static inline wuffs_base__image_decoder* +wuffs_etc2__decoder__upcast_as__wuffs_base__image_decoder( + wuffs_etc2__decoder* p) { + return (wuffs_base__image_decoder*)p; +} + +// ---------------- Public Function Prototypes + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_etc2__decoder__get_quirk( + const wuffs_etc2__decoder* self, + uint32_t a_key); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__set_quirk( + wuffs_etc2__decoder* self, + uint32_t a_key, + uint64_t a_value); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__decode_image_config( + wuffs_etc2__decoder* self, + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__decode_frame_config( + wuffs_etc2__decoder* self, + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__decode_frame( + wuffs_etc2__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__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 +wuffs_etc2__decoder__frame_dirty_rect( + const wuffs_etc2__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_etc2__decoder__num_animation_loops( + const wuffs_etc2__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_etc2__decoder__num_decoded_frame_configs( + const wuffs_etc2__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_etc2__decoder__num_decoded_frames( + const wuffs_etc2__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__restart_frame( + wuffs_etc2__decoder* self, + uint64_t a_index, + uint64_t a_io_position); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_etc2__decoder__set_report_metadata( + wuffs_etc2__decoder* self, + uint32_t a_fourcc, + bool a_report); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__tell_me_more( + wuffs_etc2__decoder* self, + wuffs_base__io_buffer* a_dst, + wuffs_base__more_information* a_minfo, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 +wuffs_etc2__decoder__workbuf_len( + const wuffs_etc2__decoder* self); + +#ifdef __cplusplus +} // extern "C" +#endif + +// ---------------- Struct Definitions + +// These structs' fields, and the sizeof them, are private implementation +// details that aren't guaranteed to be stable across Wuffs versions. +// +// See https://en.wikipedia.org/wiki/Opaque_pointer#C + +#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +struct wuffs_etc2__decoder__struct { + // Do not access the private_impl's or private_data's fields directly. There + // is no API/ABI compatibility or safety guarantee if you do so. Instead, use + // the wuffs_foo__bar__baz functions. + // + // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct + // can be stack allocated when WUFFS_IMPLEMENTATION is defined. + + struct { + uint32_t magic; + uint32_t active_coroutine; + 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; + bool f_srgb; + uint32_t f_num_buffered_blocks; + uint32_t f_dst_x; + uint32_t f_dst_y; + wuffs_base__pixel_swizzler f_swizzler; + + uint32_t p_decode_image_config; + uint32_t p_do_decode_image_config; + 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_from_src_to_colors; + } private_impl; + + struct { + uint64_t f_alphas[64]; + uint64_t f_colors[64]; + uint8_t f_buffer[4096]; + + struct { + uint16_t v_rounded_up_width; + uint16_t v_rounded_up_height; + uint64_t scratch; + } s_do_decode_image_config; + struct { + uint32_t v_remaining; + } s_do_decode_frame; + struct { + uint32_t v_bi; + uint64_t scratch; + } s_from_src_to_colors; + } private_data; + +#ifdef __cplusplus +#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + using unique_ptr = std::unique_ptr<wuffs_etc2__decoder, wuffs_unique_ptr_deleter>; + + // On failure, the alloc_etc functions return nullptr. They don't throw. + + static inline unique_ptr + alloc() { + return unique_ptr(wuffs_etc2__decoder__alloc()); + } + + static inline wuffs_base__image_decoder::unique_ptr + alloc_as__wuffs_base__image_decoder() { + return wuffs_base__image_decoder::unique_ptr( + wuffs_etc2__decoder__alloc_as__wuffs_base__image_decoder()); + } +#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + +#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) + // Disallow constructing or copying an object via standard C++ mechanisms, + // e.g. the "new" operator, as this struct is intentionally opaque. Its total + // size and field layout is not part of the public, stable, memory-safe API. + // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and + // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as + // their first argument) rather than tweaking bar.private_impl.qux fields. + // + // In C, we can just leave wuffs_foo__bar as an incomplete type (unless + // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in + // order to provide convenience methods. These forward on "this", so that you + // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". + wuffs_etc2__decoder__struct() = delete; + wuffs_etc2__decoder__struct(const wuffs_etc2__decoder__struct&) = delete; + wuffs_etc2__decoder__struct& operator=( + const wuffs_etc2__decoder__struct&) = delete; +#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) + +#if !defined(WUFFS_IMPLEMENTATION) + // As above, the size of the struct is not part of the public API, and unless + // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap + // allocated, not stack allocated. Its size is not intended to be known at + // compile time, but it is unfortunately divulged as a side effect of + // defining C++ convenience methods. Use "sizeof__T()", calling the function, + // instead of "sizeof T", invoking the operator. To make the two values + // different, so that passing the latter will be rejected by the initialize + // function, we add an arbitrary amount of dead weight. + uint8_t dead_weight[123000000]; // 123 MB. +#endif // !defined(WUFFS_IMPLEMENTATION) + + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT + initialize( + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options) { + return wuffs_etc2__decoder__initialize( + this, sizeof_star_self, wuffs_version, options); + } + + inline wuffs_base__image_decoder* + upcast_as__wuffs_base__image_decoder() { + return (wuffs_base__image_decoder*)this; + } + + inline uint64_t + get_quirk( + uint32_t a_key) const { + return wuffs_etc2__decoder__get_quirk(this, a_key); + } + + inline wuffs_base__status + set_quirk( + uint32_t a_key, + uint64_t a_value) { + return wuffs_etc2__decoder__set_quirk(this, a_key, a_value); + } + + inline wuffs_base__status + decode_image_config( + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src) { + return wuffs_etc2__decoder__decode_image_config(this, a_dst, a_src); + } + + inline wuffs_base__status + decode_frame_config( + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src) { + return wuffs_etc2__decoder__decode_frame_config(this, a_dst, a_src); + } + + inline wuffs_base__status + decode_frame( + 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) { + return wuffs_etc2__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); + } + + inline wuffs_base__rect_ie_u32 + frame_dirty_rect() const { + return wuffs_etc2__decoder__frame_dirty_rect(this); + } + + inline uint32_t + num_animation_loops() const { + return wuffs_etc2__decoder__num_animation_loops(this); + } + + inline uint64_t + num_decoded_frame_configs() const { + return wuffs_etc2__decoder__num_decoded_frame_configs(this); + } + + inline uint64_t + num_decoded_frames() const { + return wuffs_etc2__decoder__num_decoded_frames(this); + } + + inline wuffs_base__status + restart_frame( + uint64_t a_index, + uint64_t a_io_position) { + return wuffs_etc2__decoder__restart_frame(this, a_index, a_io_position); + } + + inline wuffs_base__empty_struct + set_report_metadata( + uint32_t a_fourcc, + bool a_report) { + return wuffs_etc2__decoder__set_report_metadata(this, a_fourcc, a_report); + } + + inline wuffs_base__status + tell_me_more( + wuffs_base__io_buffer* a_dst, + wuffs_base__more_information* a_minfo, + wuffs_base__io_buffer* a_src) { + return wuffs_etc2__decoder__tell_me_more(this, a_dst, a_minfo, a_src); + } + + inline wuffs_base__range_ii_u64 + workbuf_len() const { + return wuffs_etc2__decoder__workbuf_len(this); + } + +#endif // __cplusplus +}; // struct wuffs_etc2__decoder__struct + +#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) || defined(WUFFS_NONMONOLITHIC) + #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) || defined(WUFFS_NONMONOLITHIC) // ---------------- Status Codes @@ -8953,19 +9411,19 @@ #define WUFFS_GIF__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u -#define WUFFS_GIF__QUIRK_DELAY_NUM_DECODED_FRAMES 1041635328u +#define WUFFS_GIF__QUIRK_DELAY_NUM_DECODED_FRAMES 983928832u -#define WUFFS_GIF__QUIRK_FIRST_FRAME_LOCAL_PALETTE_MEANS_BLACK_BACKGROUND 1041635329u +#define WUFFS_GIF__QUIRK_FIRST_FRAME_LOCAL_PALETTE_MEANS_BLACK_BACKGROUND 983928833u -#define WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR 1041635330u +#define WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR 983928834u -#define WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA 1041635331u +#define WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA 983928835u -#define WUFFS_GIF__QUIRK_IMAGE_BOUNDS_ARE_STRICT 1041635332u +#define WUFFS_GIF__QUIRK_IMAGE_BOUNDS_ARE_STRICT 983928836u -#define WUFFS_GIF__QUIRK_REJECT_EMPTY_FRAME 1041635333u +#define WUFFS_GIF__QUIRK_REJECT_EMPTY_FRAME 983928837u -#define WUFFS_GIF__QUIRK_REJECT_EMPTY_PALETTE 1041635334u +#define WUFFS_GIF__QUIRK_REJECT_EMPTY_PALETTE 983928838u // ---------------- Struct Declarations @@ -9666,6 +10124,7 @@ extern const char wuffs_jpeg__error__missing_huffman_table[]; extern const char wuffs_jpeg__error__missing_quantization_table[]; extern const char wuffs_jpeg__error__rejected_progressive_jpeg[]; +extern const char wuffs_jpeg__error__short_sos_bitstream[]; extern const char wuffs_jpeg__error__truncated_input[]; extern const char wuffs_jpeg__error__unsupported_arithmetic_coding[]; extern const char wuffs_jpeg__error__unsupported_color_model[]; @@ -9683,7 +10142,7 @@ #define WUFFS_JPEG__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 51552191232u -#define WUFFS_JPEG__QUIRK_REJECT_PROGRESSIVE_JPEGS 1220532224u +#define WUFFS_JPEG__QUIRK_REJECT_PROGRESSIVE_JPEGS 1162824704u // ---------------- Struct Declarations @@ -10181,45 +10640,45 @@ #define WUFFS_JSON__DECODER_SRC_IO_BUFFER_LENGTH_MIN_INCL 100u -#define WUFFS_JSON__QUIRK_ALLOW_ASCII_CONTROL_CODES 1225364480u +#define WUFFS_JSON__QUIRK_ALLOW_ASCII_CONTROL_CODES 1167656960u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A 1225364481u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_A 1167656961u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U 1225364482u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_CAPITAL_U 1167656962u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E 1225364483u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_E 1167656963u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_NEW_LINE 1225364484u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_NEW_LINE 1167656964u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK 1225364485u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_QUESTION_MARK 1167656965u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE 1225364486u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_SINGLE_QUOTE 1167656966u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V 1225364487u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_V 1167656967u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS 1225364489u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS 1167656969u -#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO 1225364490u +#define WUFFS_JSON__QUIRK_ALLOW_BACKSLASH_ZERO 1167656970u -#define WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK 1225364491u +#define WUFFS_JSON__QUIRK_ALLOW_COMMENT_BLOCK 1167656971u -#define WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE 1225364492u +#define WUFFS_JSON__QUIRK_ALLOW_COMMENT_LINE 1167656972u -#define WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA 1225364493u +#define WUFFS_JSON__QUIRK_ALLOW_EXTRA_COMMA 1167656973u -#define WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS 1225364494u +#define WUFFS_JSON__QUIRK_ALLOW_INF_NAN_NUMBERS 1167656974u -#define WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR 1225364495u +#define WUFFS_JSON__QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR 1167656975u -#define WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK 1225364496u +#define WUFFS_JSON__QUIRK_ALLOW_LEADING_UNICODE_BYTE_ORDER_MARK 1167656976u -#define WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER 1225364497u +#define WUFFS_JSON__QUIRK_ALLOW_TRAILING_FILLER 1167656977u -#define WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF 1225364498u +#define WUFFS_JSON__QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF 1167656978u -#define WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T 1225364499u +#define WUFFS_JSON__QUIRK_JSON_POINTER_ALLOW_TILDE_N_TILDE_R_TILDE_T 1167656979u -#define WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE 1225364500u +#define WUFFS_JSON__QUIRK_REPLACE_INVALID_UNICODE 1167656980u // ---------------- Struct Declarations @@ -10465,9 +10924,9 @@ #define WUFFS_LZMA__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 4294967568u -#define WUFFS_LZMA__QUIRK_ALLOW_NON_ZERO_INITIAL_BYTE 1348001792u +#define WUFFS_LZMA__QUIRK_ALLOW_NON_ZERO_INITIAL_BYTE 1290294272u -#define WUFFS_LZMA__QUIRK_FORMAT_EXTENSION 1348001793u +#define WUFFS_LZMA__QUIRK_FORMAT_EXTENSION 1290294273u // ---------------- Struct Declarations @@ -11026,7 +11485,7 @@ #define WUFFS_LZW__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u -#define WUFFS_LZW__QUIRK_LITERAL_WIDTH_PLUS_ONE 1348378624u +#define WUFFS_LZW__QUIRK_LITERAL_WIDTH_PLUS_ONE 1290672128u // ---------------- Struct Declarations @@ -11982,7 +12441,7 @@ // ---------------- Public Consts -#define WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE 2113790976u +#define WUFFS_ZLIB__QUIRK_JUST_RAW_DEFLATE 2056083456u #define WUFFS_ZLIB__DECODER_DST_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0u @@ -13343,22 +13802,22 @@ #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__SHA256) || defined(WUFFS_NONMONOLITHIC) -#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) || defined(WUFFS_NONMONOLITHIC) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) || defined(WUFFS_NONMONOLITHIC) // ---------------- Status Codes -extern const char wuffs_tga__error__bad_header[]; -extern const char wuffs_tga__error__bad_run_length_encoding[]; -extern const char wuffs_tga__error__truncated_input[]; -extern const char wuffs_tga__error__unsupported_tga_file[]; +extern const char wuffs_targa__error__bad_header[]; +extern const char wuffs_targa__error__bad_run_length_encoding[]; +extern const char wuffs_targa__error__truncated_input[]; +extern const char wuffs_targa__error__unsupported_targa_file[]; // ---------------- Public Consts -#define WUFFS_TGA__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u +#define WUFFS_TARGA__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u // ---------------- Struct Declarations -typedef struct wuffs_tga__decoder__struct wuffs_tga__decoder; +typedef struct wuffs_targa__decoder__struct wuffs_targa__decoder; #ifdef __cplusplus extern "C" { @@ -13373,14 +13832,14 @@ // Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT -wuffs_tga__decoder__initialize( - wuffs_tga__decoder* self, +wuffs_targa__decoder__initialize( + wuffs_targa__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, uint32_t options); size_t -sizeof__wuffs_tga__decoder(void); +sizeof__wuffs_targa__decoder(void); // ---------------- Allocs @@ -13390,19 +13849,19 @@ // calling free on the returned pointer. That pointer is effectively a C++ // std::unique_ptr<T, wuffs_unique_ptr_deleter>. -wuffs_tga__decoder* -wuffs_tga__decoder__alloc(void); +wuffs_targa__decoder* +wuffs_targa__decoder__alloc(void); static inline wuffs_base__image_decoder* -wuffs_tga__decoder__alloc_as__wuffs_base__image_decoder(void) { - return (wuffs_base__image_decoder*)(wuffs_tga__decoder__alloc()); +wuffs_targa__decoder__alloc_as__wuffs_base__image_decoder(void) { + return (wuffs_base__image_decoder*)(wuffs_targa__decoder__alloc()); } // ---------------- Upcasts static inline wuffs_base__image_decoder* -wuffs_tga__decoder__upcast_as__wuffs_base__image_decoder( - wuffs_tga__decoder* p) { +wuffs_targa__decoder__upcast_as__wuffs_base__image_decoder( + wuffs_targa__decoder* p) { return (wuffs_base__image_decoder*)p; } @@ -13410,35 +13869,35 @@ WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_tga__decoder__get_quirk( - const wuffs_tga__decoder* self, +wuffs_targa__decoder__get_quirk( + const wuffs_targa__decoder* self, uint32_t a_key); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__set_quirk( - wuffs_tga__decoder* self, +wuffs_targa__decoder__set_quirk( + wuffs_targa__decoder* self, uint32_t a_key, uint64_t a_value); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__decode_image_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__decode_image_config( + wuffs_targa__decoder* self, wuffs_base__image_config* a_dst, wuffs_base__io_buffer* a_src); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__decode_frame_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__decode_frame_config( + wuffs_targa__decoder* self, wuffs_base__frame_config* a_dst, wuffs_base__io_buffer* a_src); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__decode_frame( - wuffs_tga__decoder* self, +wuffs_targa__decoder__decode_frame( + wuffs_targa__decoder* self, wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__pixel_blend a_blend, @@ -13447,50 +13906,50 @@ WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 -wuffs_tga__decoder__frame_dirty_rect( - const wuffs_tga__decoder* self); +wuffs_targa__decoder__frame_dirty_rect( + const wuffs_targa__decoder* self); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t -wuffs_tga__decoder__num_animation_loops( - const wuffs_tga__decoder* self); +wuffs_targa__decoder__num_animation_loops( + const wuffs_targa__decoder* self); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_tga__decoder__num_decoded_frame_configs( - const wuffs_tga__decoder* self); +wuffs_targa__decoder__num_decoded_frame_configs( + const wuffs_targa__decoder* self); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_tga__decoder__num_decoded_frames( - const wuffs_tga__decoder* self); +wuffs_targa__decoder__num_decoded_frames( + const wuffs_targa__decoder* self); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__restart_frame( - wuffs_tga__decoder* self, +wuffs_targa__decoder__restart_frame( + wuffs_targa__decoder* self, uint64_t a_index, uint64_t a_io_position); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct -wuffs_tga__decoder__set_report_metadata( - wuffs_tga__decoder* self, +wuffs_targa__decoder__set_report_metadata( + wuffs_targa__decoder* self, uint32_t a_fourcc, bool a_report); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__tell_me_more( - wuffs_tga__decoder* self, +wuffs_targa__decoder__tell_me_more( + wuffs_targa__decoder* self, wuffs_base__io_buffer* a_dst, wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src); WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 -wuffs_tga__decoder__workbuf_len( - const wuffs_tga__decoder* self); +wuffs_targa__decoder__workbuf_len( + const wuffs_targa__decoder* self); #ifdef __cplusplus } // extern "C" @@ -13505,7 +13964,7 @@ #if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) -struct wuffs_tga__decoder__struct { +struct wuffs_targa__decoder__struct { // Do not access the private_impl's or private_data's fields directly. There // is no API/ABI compatibility or safety guarantee if you do so. Instead, use // the wuffs_foo__bar__baz functions. @@ -13569,19 +14028,19 @@ #ifdef __cplusplus #if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) - using unique_ptr = std::unique_ptr<wuffs_tga__decoder, wuffs_unique_ptr_deleter>; + using unique_ptr = std::unique_ptr<wuffs_targa__decoder, wuffs_unique_ptr_deleter>; // On failure, the alloc_etc functions return nullptr. They don't throw. static inline unique_ptr alloc() { - return unique_ptr(wuffs_tga__decoder__alloc()); + return unique_ptr(wuffs_targa__decoder__alloc()); } static inline wuffs_base__image_decoder::unique_ptr alloc_as__wuffs_base__image_decoder() { return wuffs_base__image_decoder::unique_ptr( - wuffs_tga__decoder__alloc_as__wuffs_base__image_decoder()); + wuffs_targa__decoder__alloc_as__wuffs_base__image_decoder()); } #endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) @@ -13597,10 +14056,10 @@ // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in // order to provide convenience methods. These forward on "this", so that you // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". - wuffs_tga__decoder__struct() = delete; - wuffs_tga__decoder__struct(const wuffs_tga__decoder__struct&) = delete; - wuffs_tga__decoder__struct& operator=( - const wuffs_tga__decoder__struct&) = delete; + wuffs_targa__decoder__struct() = delete; + wuffs_targa__decoder__struct(const wuffs_targa__decoder__struct&) = delete; + wuffs_targa__decoder__struct& operator=( + const wuffs_targa__decoder__struct&) = delete; #endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) #if !defined(WUFFS_IMPLEMENTATION) @@ -13620,7 +14079,7 @@ size_t sizeof_star_self, uint64_t wuffs_version, uint32_t options) { - return wuffs_tga__decoder__initialize( + return wuffs_targa__decoder__initialize( this, sizeof_star_self, wuffs_version, options); } @@ -13632,28 +14091,28 @@ inline uint64_t get_quirk( uint32_t a_key) const { - return wuffs_tga__decoder__get_quirk(this, a_key); + return wuffs_targa__decoder__get_quirk(this, a_key); } inline wuffs_base__status set_quirk( uint32_t a_key, uint64_t a_value) { - return wuffs_tga__decoder__set_quirk(this, a_key, a_value); + return wuffs_targa__decoder__set_quirk(this, a_key, a_value); } inline wuffs_base__status decode_image_config( wuffs_base__image_config* a_dst, wuffs_base__io_buffer* a_src) { - return wuffs_tga__decoder__decode_image_config(this, a_dst, a_src); + return wuffs_targa__decoder__decode_image_config(this, a_dst, a_src); } inline wuffs_base__status decode_frame_config( wuffs_base__frame_config* a_dst, wuffs_base__io_buffer* a_src) { - return wuffs_tga__decoder__decode_frame_config(this, a_dst, a_src); + return wuffs_targa__decoder__decode_frame_config(this, a_dst, a_src); } inline wuffs_base__status @@ -13663,41 +14122,41 @@ wuffs_base__pixel_blend a_blend, wuffs_base__slice_u8 a_workbuf, wuffs_base__decode_frame_options* a_opts) { - return wuffs_tga__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); + return wuffs_targa__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); } inline wuffs_base__rect_ie_u32 frame_dirty_rect() const { - return wuffs_tga__decoder__frame_dirty_rect(this); + return wuffs_targa__decoder__frame_dirty_rect(this); } inline uint32_t num_animation_loops() const { - return wuffs_tga__decoder__num_animation_loops(this); + return wuffs_targa__decoder__num_animation_loops(this); } inline uint64_t num_decoded_frame_configs() const { - return wuffs_tga__decoder__num_decoded_frame_configs(this); + return wuffs_targa__decoder__num_decoded_frame_configs(this); } inline uint64_t num_decoded_frames() const { - return wuffs_tga__decoder__num_decoded_frames(this); + return wuffs_targa__decoder__num_decoded_frames(this); } inline wuffs_base__status restart_frame( uint64_t a_index, uint64_t a_io_position) { - return wuffs_tga__decoder__restart_frame(this, a_index, a_io_position); + return wuffs_targa__decoder__restart_frame(this, a_index, a_io_position); } inline wuffs_base__empty_struct set_report_metadata( uint32_t a_fourcc, bool a_report) { - return wuffs_tga__decoder__set_report_metadata(this, a_fourcc, a_report); + return wuffs_targa__decoder__set_report_metadata(this, a_fourcc, a_report); } inline wuffs_base__status @@ -13705,20 +14164,397 @@ wuffs_base__io_buffer* a_dst, wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src) { - return wuffs_tga__decoder__tell_me_more(this, a_dst, a_minfo, a_src); + return wuffs_targa__decoder__tell_me_more(this, a_dst, a_minfo, a_src); } inline wuffs_base__range_ii_u64 workbuf_len() const { - return wuffs_tga__decoder__workbuf_len(this); + return wuffs_targa__decoder__workbuf_len(this); } #endif // __cplusplus -}; // struct wuffs_tga__decoder__struct +}; // struct wuffs_targa__decoder__struct #endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) -#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) || defined(WUFFS_NONMONOLITHIC) +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) || defined(WUFFS_NONMONOLITHIC) + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) || defined(WUFFS_NONMONOLITHIC) + +// ---------------- Status Codes + +extern const char wuffs_thumbhash__error__bad_header[]; +extern const char wuffs_thumbhash__error__truncated_input[]; + +// ---------------- Public Consts + +#define WUFFS_THUMBHASH__QUIRK_JUST_RAW_THUMBHASH 1712283648u + +#define WUFFS_THUMBHASH__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE 0u + +// ---------------- Struct Declarations + +typedef struct wuffs_thumbhash__decoder__struct wuffs_thumbhash__decoder; + +#ifdef __cplusplus +extern "C" { +#endif + +// ---------------- Public Initializer Prototypes + +// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self, +// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)". +// +// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version. +// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options. + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT +wuffs_thumbhash__decoder__initialize( + wuffs_thumbhash__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options); + +size_t +sizeof__wuffs_thumbhash__decoder(void); + +// ---------------- Allocs + +// These functions allocate and initialize Wuffs structs. They return NULL if +// memory allocation fails. If they return non-NULL, there is no need to call +// wuffs_foo__bar__initialize, but the caller is responsible for eventually +// calling free on the returned pointer. That pointer is effectively a C++ +// std::unique_ptr<T, wuffs_unique_ptr_deleter>. + +wuffs_thumbhash__decoder* +wuffs_thumbhash__decoder__alloc(void); + +static inline wuffs_base__image_decoder* +wuffs_thumbhash__decoder__alloc_as__wuffs_base__image_decoder(void) { + return (wuffs_base__image_decoder*)(wuffs_thumbhash__decoder__alloc()); +} + +// ---------------- Upcasts + +static inline wuffs_base__image_decoder* +wuffs_thumbhash__decoder__upcast_as__wuffs_base__image_decoder( + wuffs_thumbhash__decoder* p) { + return (wuffs_base__image_decoder*)p; +} + +// ---------------- Public Function Prototypes + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_thumbhash__decoder__get_quirk( + const wuffs_thumbhash__decoder* self, + uint32_t a_key); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__set_quirk( + wuffs_thumbhash__decoder* self, + uint32_t a_key, + uint64_t a_value); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__decode_image_config( + wuffs_thumbhash__decoder* self, + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__decode_frame_config( + wuffs_thumbhash__decoder* self, + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__decode_frame( + wuffs_thumbhash__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__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 +wuffs_thumbhash__decoder__frame_dirty_rect( + const wuffs_thumbhash__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_thumbhash__decoder__num_animation_loops( + const wuffs_thumbhash__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_thumbhash__decoder__num_decoded_frame_configs( + const wuffs_thumbhash__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_thumbhash__decoder__num_decoded_frames( + const wuffs_thumbhash__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__restart_frame( + wuffs_thumbhash__decoder* self, + uint64_t a_index, + uint64_t a_io_position); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_thumbhash__decoder__set_report_metadata( + wuffs_thumbhash__decoder* self, + uint32_t a_fourcc, + bool a_report); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__tell_me_more( + wuffs_thumbhash__decoder* self, + wuffs_base__io_buffer* a_dst, + wuffs_base__more_information* a_minfo, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 +wuffs_thumbhash__decoder__workbuf_len( + const wuffs_thumbhash__decoder* self); + +#ifdef __cplusplus +} // extern "C" +#endif + +// ---------------- Struct Definitions + +// These structs' fields, and the sizeof them, are private implementation +// details that aren't guaranteed to be stable across Wuffs versions. +// +// See https://en.wikipedia.org/wiki/Opaque_pointer#C + +#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +struct wuffs_thumbhash__decoder__struct { + // Do not access the private_impl's or private_data's fields directly. There + // is no API/ABI compatibility or safety guarantee if you do so. Instead, use + // the wuffs_foo__bar__baz functions. + // + // It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct + // can be stack allocated when WUFFS_IMPLEMENTATION is defined. + + struct { + uint32_t magic; + uint32_t active_coroutine; + wuffs_base__vtable vtable_for__wuffs_base__image_decoder; + wuffs_base__vtable null_vtable; + + uint32_t f_pixfmt; + uint8_t f_w_dimension_code; + uint8_t f_h_dimension_code; + uint8_t f_call_sequence; + uint8_t f_frame_config_io_position; + uint64_t f_l_dc; + uint64_t f_p_dc; + uint64_t f_q_dc; + uint64_t f_a_dc; + bool f_quirk_just_raw_thumbhash; + uint8_t f_l_scale; + uint8_t f_p_scale; + uint8_t f_q_scale; + uint8_t f_a_scale; + uint8_t f_has_alpha; + uint8_t f_l_count; + uint8_t f_is_landscape; + uint32_t f_lx; + uint32_t f_ly; + wuffs_base__pixel_swizzler f_swizzler; + + uint32_t p_decode_image_config; + uint32_t p_do_decode_image_config; + 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_from_src_to_coeffs; + } private_impl; + + struct { + uint32_t f_lac[32]; + uint32_t f_pac[8]; + uint32_t f_qac[8]; + uint32_t f_aac[16]; + uint8_t f_pixels[32][128]; + + struct { + uint64_t scratch; + } s_do_decode_image_config; + struct { + uint32_t v_cy; + uint32_t v_cx; + uint32_t v_i; + bool v_has_bits; + } s_from_src_to_coeffs; + } private_data; + +#ifdef __cplusplus +#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + using unique_ptr = std::unique_ptr<wuffs_thumbhash__decoder, wuffs_unique_ptr_deleter>; + + // On failure, the alloc_etc functions return nullptr. They don't throw. + + static inline unique_ptr + alloc() { + return unique_ptr(wuffs_thumbhash__decoder__alloc()); + } + + static inline wuffs_base__image_decoder::unique_ptr + alloc_as__wuffs_base__image_decoder() { + return wuffs_base__image_decoder::unique_ptr( + wuffs_thumbhash__decoder__alloc_as__wuffs_base__image_decoder()); + } +#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + +#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) + // Disallow constructing or copying an object via standard C++ mechanisms, + // e.g. the "new" operator, as this struct is intentionally opaque. Its total + // size and field layout is not part of the public, stable, memory-safe API. + // Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and + // call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as + // their first argument) rather than tweaking bar.private_impl.qux fields. + // + // In C, we can just leave wuffs_foo__bar as an incomplete type (unless + // WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in + // order to provide convenience methods. These forward on "this", so that you + // can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)". + wuffs_thumbhash__decoder__struct() = delete; + wuffs_thumbhash__decoder__struct(const wuffs_thumbhash__decoder__struct&) = delete; + wuffs_thumbhash__decoder__struct& operator=( + const wuffs_thumbhash__decoder__struct&) = delete; +#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION) + +#if !defined(WUFFS_IMPLEMENTATION) + // As above, the size of the struct is not part of the public API, and unless + // WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap + // allocated, not stack allocated. Its size is not intended to be known at + // compile time, but it is unfortunately divulged as a side effect of + // defining C++ convenience methods. Use "sizeof__T()", calling the function, + // instead of "sizeof T", invoking the operator. To make the two values + // different, so that passing the latter will be rejected by the initialize + // function, we add an arbitrary amount of dead weight. + uint8_t dead_weight[123000000]; // 123 MB. +#endif // !defined(WUFFS_IMPLEMENTATION) + + inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT + initialize( + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options) { + return wuffs_thumbhash__decoder__initialize( + this, sizeof_star_self, wuffs_version, options); + } + + inline wuffs_base__image_decoder* + upcast_as__wuffs_base__image_decoder() { + return (wuffs_base__image_decoder*)this; + } + + inline uint64_t + get_quirk( + uint32_t a_key) const { + return wuffs_thumbhash__decoder__get_quirk(this, a_key); + } + + inline wuffs_base__status + set_quirk( + uint32_t a_key, + uint64_t a_value) { + return wuffs_thumbhash__decoder__set_quirk(this, a_key, a_value); + } + + inline wuffs_base__status + decode_image_config( + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src) { + return wuffs_thumbhash__decoder__decode_image_config(this, a_dst, a_src); + } + + inline wuffs_base__status + decode_frame_config( + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src) { + return wuffs_thumbhash__decoder__decode_frame_config(this, a_dst, a_src); + } + + inline wuffs_base__status + decode_frame( + 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) { + return wuffs_thumbhash__decoder__decode_frame(this, a_dst, a_src, a_blend, a_workbuf, a_opts); + } + + inline wuffs_base__rect_ie_u32 + frame_dirty_rect() const { + return wuffs_thumbhash__decoder__frame_dirty_rect(this); + } + + inline uint32_t + num_animation_loops() const { + return wuffs_thumbhash__decoder__num_animation_loops(this); + } + + inline uint64_t + num_decoded_frame_configs() const { + return wuffs_thumbhash__decoder__num_decoded_frame_configs(this); + } + + inline uint64_t + num_decoded_frames() const { + return wuffs_thumbhash__decoder__num_decoded_frames(this); + } + + inline wuffs_base__status + restart_frame( + uint64_t a_index, + uint64_t a_io_position) { + return wuffs_thumbhash__decoder__restart_frame(this, a_index, a_io_position); + } + + inline wuffs_base__empty_struct + set_report_metadata( + uint32_t a_fourcc, + bool a_report) { + return wuffs_thumbhash__decoder__set_report_metadata(this, a_fourcc, a_report); + } + + inline wuffs_base__status + tell_me_more( + wuffs_base__io_buffer* a_dst, + wuffs_base__more_information* a_minfo, + wuffs_base__io_buffer* a_src) { + return wuffs_thumbhash__decoder__tell_me_more(this, a_dst, a_minfo, a_src); + } + + inline wuffs_base__range_ii_u64 + workbuf_len() const { + return wuffs_thumbhash__decoder__workbuf_len(this); + } + +#endif // __cplusplus +}; // struct wuffs_thumbhash__decoder__struct + +#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION) + +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) || defined(WUFFS_NONMONOLITHIC) #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8) || defined(WUFFS_NONMONOLITHIC) @@ -15134,7 +15970,7 @@ // ---------------- Public Consts -#define WUFFS_XZ__QUIRK_DECODE_STANDALONE_CONCATENATED_STREAMS 2021322752u +#define WUFFS_XZ__QUIRK_DECODE_STANDALONE_CONCATENATED_STREAMS 1963655168u #define WUFFS_XZ__DECODER_DST_HISTORY_RETAIN_LENGTH_MAX_INCL_WORST_CASE 0u @@ -15723,19 +16559,26 @@ // // The default SelectDecoder accepts the FOURCC codes listed below. For // modular builds (i.e. when #define'ing WUFFS_CONFIG__MODULES), acceptance - // of the ETC file format is optional (for each value of ETC) and depends on + // of the FOO file format is optional (for each value of FOO) and depends on // the corresponding module to be enabled at compile time (i.e. #define'ing - // WUFFS_CONFIG__MODULE__ETC). + // WUFFS_CONFIG__MODULE__FOO). + // // - WUFFS_BASE__FOURCC__BMP + // - WUFFS_BASE__FOURCC__ETC2 // - WUFFS_BASE__FOURCC__GIF // - WUFFS_BASE__FOURCC__JPEG // - WUFFS_BASE__FOURCC__NIE // - WUFFS_BASE__FOURCC__NPBM // - WUFFS_BASE__FOURCC__PNG // - WUFFS_BASE__FOURCC__QOI - // - WUFFS_BASE__FOURCC__TGA + // - WUFFS_BASE__FOURCC__TARGA + // - WUFFS_BASE__FOURCC__TH // - WUFFS_BASE__FOURCC__WBMP // - WUFFS_BASE__FOURCC__WEBP + // + // The FOOBAR in WUFFS_BASE__FOURCC__FOBA is limited to four characters, but + // the FOOBAR in the corresponding WUFFS_CONFIG__MODULE__FOOBAR macro might + // be fuller and longer. For example, NPBM / NETPBM or TH / THUMBHASH. virtual wuffs_base__image_decoder::unique_ptr // SelectDecoder(uint32_t fourcc, wuffs_base__slice_u8 prefix_data, @@ -15744,8 +16587,8 @@ // HandleMetadata acknowledges image metadata. minfo.flavor will be one of: // - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_RAW_PASSTHROUGH // - WUFFS_BASE__MORE_INFORMATION__FLAVOR__METADATA_PARSED - // If it is ETC__METADATA_RAW_ETC then raw contains the metadata bytes. Those - // bytes should not be retained beyond the the HandleMetadata call. + // If it is METADATA_RAW_PASSTHROUGH then raw contains the metadata bytes. + // Those bytes should not be retained beyond the the HandleMetadata call. // // minfo.metadata__fourcc() will typically match one of the // DecodeImageArgFlags bits. For example, if (REPORT_METADATA_CHRM | @@ -15759,6 +16602,7 @@ // SelectPixfmt returns the destination pixel format for AllocPixbuf. It // should return wuffs_base__make_pixel_format(etc) called with one of: + // - WUFFS_BASE__PIXEL_FORMAT__Y // - WUFFS_BASE__PIXEL_FORMAT__BGR_565 // - WUFFS_BASE__PIXEL_FORMAT__BGR // - WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL @@ -15861,7 +16705,7 @@ // DefaultValue returns 0. static DecodeImageArgFlags DefaultValue(); - // TODO: support all of the REPORT_METADATA_ETC flags, not just CHRM, EXIF, + // TODO: support all of the REPORT_METADATA_FOO flags, not just CHRM, EXIF, // GAMA, ICCP, KVP, SRGB and XMP. // Background Color. @@ -16108,6 +16952,131 @@ #endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR) +// ---------------- Wuffs' reimplementation of the STB API. +// +// This is a drop-in replacement of that third-party library. +// +// Disabled by default, unless you #define the +// WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB macro beforehand. +// +// For API docs, see https://github.com/nothings/stb + +#if defined(WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB) + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(WUFFS_CONFIG__STATIC_FUNCTIONS) || defined(STB_IMAGE_STATIC) +#define WUFFS_DROP_IN__STB__MAYBE_STATIC static +#else +#define WUFFS_DROP_IN__STB__MAYBE_STATIC +#endif + +enum { + STBI_default = 0, + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +typedef struct { + int (*read)(void* user, char* data, int size); + void (*skip)(void* user, int n); + int (*eof)(void* user); +} stbi_io_callbacks; + +// -------- + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info_from_memory( // + stbi_uc const* buffer, // + int len, // + int* x, // + int* y, // + int* comp); + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load_from_memory( // + stbi_uc const* buffer, // + int len, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels); + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info_from_callbacks( // + stbi_io_callbacks const* clbk, // + void* user, // + int* x, // + int* y, // + int* comp); + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load_from_callbacks( // + stbi_io_callbacks const* clbk, // + void* user, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels); + +// -------- + +#if !defined(STBI_NO_STDIO) + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info( // + char const* filename, // + int* x, // + int* y, // + int* comp); + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load( // + char const* filename, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels); + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info_from_file( // + FILE* f, // + int* x, // + int* y, // + int* comp); + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load_from_file( // + FILE* f, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels); + +#endif // !defined(STBI_NO_STDIO) + +// -------- + +WUFFS_DROP_IN__STB__MAYBE_STATIC void // +stbi_image_free( // + void* retval_from_stbi_load); + +WUFFS_DROP_IN__STB__MAYBE_STATIC const char* // +stbi_failure_reason(void); + +#ifdef __cplusplus +} +#endif + +#endif // defined (WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB) + // ‼ WUFFS C HEADER ENDS HERE. #ifdef WUFFS_IMPLEMENTATION @@ -16280,12 +17249,24 @@ // ---------------- Numeric Types (Utility) +#define wuffs_base__utility__i64_divide(a, b) \ + ((uint64_t)(((int64_t)(a)) / ((int64_t)(b)))) + #define wuffs_base__utility__sign_extend_convert_u8_u32(a) \ ((uint32_t)(int32_t)(int8_t)(a)) +#define wuffs_base__utility__sign_extend_convert_u8_u64(a) \ + ((uint64_t)(int64_t)(int8_t)(a)) + #define wuffs_base__utility__sign_extend_convert_u16_u32(a) \ ((uint32_t)(int32_t)(int16_t)(a)) +#define wuffs_base__utility__sign_extend_convert_u16_u64(a) \ + ((uint64_t)(int64_t)(int16_t)(a)) + +#define wuffs_base__utility__sign_extend_convert_u32_u64(a) \ + ((uint64_t)(int64_t)(int32_t)(a)) + #define wuffs_base__utility__sign_extend_rshift_u32(a, n) \ ((uint32_t)(((int32_t)(a)) >> (n))) @@ -21993,26 +22974,31 @@ int32_t fourcc; const char* magic; } table[] = { - {-0x30302020, "\x01\x00\x00"}, // '00 'be - {+0x475A2020, "\x02\x1F\x8B\x08"}, // GZ - {+0x5A535444, "\x03\x28\xB5\x2F\xFD"}, // ZSTD - {+0x425A3220, "\x02\x42\x5A\x68"}, // BZ2 - {+0x424D5020, "\x01\x42\x4D"}, // BMP - {+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF - {+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian) - {+0x4C5A4950, "\x04\x4C\x5A\x49\x50\x01"}, // LZIP - {+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian) - {+0x4E50424D, "\x02\x50\x35\x0A"}, // NPBM (P5; *.pgm) - {+0x4E50424D, "\x02\x50\x36\x0A"}, // NPBM (P6; *.ppm) - {-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF - {+0x4C5A4D41, "\x04\x5D\x00\x10\x00\x00"}, // LZMA - {+0x4C5A4D41, "\x02\x5D\x00\x00"}, // LZMA - {+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE - {+0x514F4920, "\x03\x71\x6F\x69\x66"}, // QOI - {+0x5A4C4942, "\x01\x78\x9C"}, // ZLIB - {+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG - {+0x585A2020, "\x04\xFD\x37\x7A\x58\x5A"}, // XZ - {+0x4A504547, "\x01\xFF\xD8"}, // JPEG + {-0x30302020, "\x01\x00\x00"}, // '00 'be + {+0x41425852, "\x03\x03\x00\x08\x00"}, // ABXR + {+0x475A2020, "\x02\x1F\x8B\x08"}, // GZ + {+0x5A535444, "\x03\x28\xB5\x2F\xFD"}, // ZSTD + {+0x584D4C20, "\x05\x3C\x3F\x78\x6D\x6C\x20"}, // XML + {+0x41425853, "\x03\x41\x42\x58\x00"}, // ABXS + {+0x425A3220, "\x02\x42\x5A\x68"}, // BZ2 + {+0x424D5020, "\x01\x42\x4D"}, // BMP + {+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF + {+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian) + {+0x4C5A4950, "\x04\x4C\x5A\x49\x50\x01"}, // LZIP + {+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian) + {+0x45544332, "\x03\x50\x4B\x4D\x20"}, // ETC2 (*.pkm) + {+0x4E50424D, "\x02\x50\x35\x0A"}, // NPBM (P5; *.pgm) + {+0x4E50424D, "\x02\x50\x36\x0A"}, // NPBM (P6; *.ppm) + {-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF + {+0x4C5A4D41, "\x04\x5D\x00\x10\x00\x00"}, // LZMA + {+0x4C5A4D41, "\x02\x5D\x00\x00"}, // LZMA + {+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE + {+0x514F4920, "\x03\x71\x6F\x69\x66"}, // QOI + {+0x5A4C4942, "\x01\x78\x9C"}, // ZLIB + {+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG + {+0x54482020, "\x02\xC3\xBE\xFE"}, // TH + {+0x585A2020, "\x04\xFD\x37\x7A\x58\x5A"}, // XZ + {+0x4A504547, "\x01\xFF\xD8"}, // JPEG }; static const size_t table_len = sizeof(table) / sizeof(table[0]); @@ -22246,9 +23232,8 @@ wuffs_base__peek_u32le__no_bounds_check(row + (4 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__RGB: - return wuffs_private_impl__swap_u32_argb_abgr( - 0xFF000000 | - wuffs_base__peek_u24le__no_bounds_check(row + (3 * ((size_t)x)))); + return 0xFF000000 | + wuffs_base__peek_u24be__no_bounds_check(row + (3 * ((size_t)x))); case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: return wuffs_private_impl__swap_u32_argb_abgr( wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( @@ -22354,6 +23339,10 @@ wuffs_base__color_u32_argb_premul__as__color_u64_argb_nonpremul( color)); break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + wuffs_base__poke_u32le__no_bounds_check( + row + (4 * ((size_t)x)), (color >> 31) ? (color | 0xFF000000) : 0); + break; case WUFFS_BASE__PIXEL_FORMAT__RGB: wuffs_base__poke_u24le__no_bounds_check( @@ -22960,6 +23949,34 @@ // -------- static uint64_t // +wuffs_private_impl__swizzle_squash_align4_y_8888(uint8_t* dst_ptr, + size_t dst_len, + const uint8_t* src_ptr, + size_t src_len, + bool nonpremul) { + size_t len = (dst_len < src_len ? dst_len : src_len) / 4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + + size_t n = len; + while (n--) { + uint32_t argb = wuffs_base__peek_u32le__no_bounds_check(s); + if (nonpremul) { + argb = + wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(argb); + } + uint32_t s0 = wuffs_base__color_u32_argb_premul__as__color_u8_gray(argb); + wuffs_base__poke_u32le__no_bounds_check( + d, (argb & 0xFF000000) | (s0 * 0x010101)); + s += 4; + d += 4; + } + return len; +} + +// -------- + +static uint64_t // wuffs_private_impl__swizzle_swap_rgb_bgr(uint8_t* dst_ptr, size_t dst_len, uint8_t* dst_palette_ptr, @@ -26785,6 +27802,62 @@ // -------- static uint64_t // +wuffs_private_impl__swizzle_y__bgr(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len3 = src_len / 3; + size_t len = (dst_len < src_len3) ? dst_len : src_len3; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = + 0xFF000000 | wuffs_base__peek_u24le__no_bounds_check(s + (0 * 3)); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); + + s += 1 * 3; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__bgr_565(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len2 = src_len / 2; + size_t len = (dst_len < src_len2) ? dst_len : src_len2; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = wuffs_base__color_u16_rgb_565__as__color_u32_argb_premul( + wuffs_base__peek_u16le__no_bounds_check(s + (0 * 2))); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); + + s += 1 * 2; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // wuffs_private_impl__swizzle_y__bgra_nonpremul__src(uint8_t* dst_ptr, size_t dst_len, uint8_t* dst_palette_ptr, @@ -26797,6 +27870,8 @@ const uint8_t* s = src_ptr; size_t n = len; + // TODO: unroll. + while (n >= 1) { uint32_t s0 = wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( @@ -26825,6 +27900,8 @@ const uint8_t* s = src_ptr; size_t n = len; + // TODO: unroll. + while (n >= 1) { uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); @@ -26840,6 +27917,154 @@ } static uint64_t // +wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src( + uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len8 = src_len / 8; + size_t len = (dst_len < src_len8) ? dst_len : src_len8; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + d[0] = wuffs_base__color_u64_argb_nonpremul__as__color_u8_gray( + wuffs_base__peek_u64le__no_bounds_check(s + (0 * 8))); + + s += 1 * 8; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over( + uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len8 = src_len / 8; + size_t len = (dst_len < src_len8) ? dst_len : src_len8; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + // Extract 16-bit color components. + uint32_t dr = 0x101 * ((uint32_t)d[0]); + uint32_t dg = 0x101 * ((uint32_t)d[0]); + uint32_t db = 0x101 * ((uint32_t)d[0]); + uint32_t sa = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 6)); + uint32_t sr = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 4)); + uint32_t sg = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 2)); + uint32_t sb = ((uint32_t)wuffs_base__peek_u16le__no_bounds_check(s + 0)); + + // Calculate the inverse of the src-alpha: how much of the dst to keep. + uint32_t ia = 0xFFFF - sa; + + // Composite src (nonpremul) over dst (premul). + dr = ((sr * sa) + (dr * ia)) / 0xFFFF; + dg = ((sg * sa) + (dg * ia)) / 0xFFFF; + db = ((sb * sa) + (db * ia)) / 0xFFFF; + + // Convert to 16-bit color to 8-bit gray. + uint32_t weighted_average = + (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; + d[0] = (uint8_t)(weighted_average >> 24); + + s += 1 * 8; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__bgra_premul__src(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len4 = src_len / 4; + size_t len = (dst_len < src_len4) ? dst_len : src_len4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); + + s += 1 * 4; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__bgra_premul__src_over(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len4 = src_len / 4; + size_t len = (dst_len < src_len4) ? dst_len : src_len4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + // Extract 16-bit color components. + uint32_t dr = 0x101 * ((uint32_t)d[0]); + uint32_t dg = 0x101 * ((uint32_t)d[0]); + uint32_t db = 0x101 * ((uint32_t)d[0]); + uint32_t sa = 0x101 * ((uint32_t)s[3]); + uint32_t sr = 0x101 * ((uint32_t)s[2]); + uint32_t sg = 0x101 * ((uint32_t)s[1]); + uint32_t sb = 0x101 * ((uint32_t)s[0]); + + // Calculate the inverse of the src-alpha: how much of the dst to keep. + uint32_t ia = 0xFFFF - sa; + + // Composite src (premul) over dst (premul). + dr = sr + ((dr * ia) / 0xFFFF); + dg = sg + ((dg * ia) / 0xFFFF); + db = sb + ((db * ia) / 0xFFFF); + + // Convert to 16-bit color to 8-bit gray. + uint32_t weighted_average = + (19595 * dr) + (38470 * dg) + (7471 * db) + 32768; + d[0] = (uint8_t)(weighted_average >> 24); + + s += 1 * 4; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // wuffs_private_impl__swizzle_y__bgrx(uint8_t* dst_ptr, size_t dst_len, uint8_t* dst_palette_ptr, @@ -26852,6 +28077,8 @@ const uint8_t* s = src_ptr; size_t n = len; + // TODO: unroll. + while (n >= 1) { uint32_t s0 = 0xFF000000 | wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)); @@ -26866,6 +28093,152 @@ } static uint64_t // +wuffs_private_impl__swizzle_y__rgb(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len3 = src_len / 3; + size_t len = (dst_len < src_len3) ? dst_len : src_len3; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = + 0xFF000000 | wuffs_base__peek_u24be__no_bounds_check(s + (0 * 3)); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); + + s += 1 * 3; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__rgba_nonpremul__src(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len4 = src_len / 4; + size_t len = (dst_len < src_len4) ? dst_len : src_len4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = wuffs_private_impl__swap_u32_argb_abgr( + wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul( + wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4)))); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); + + s += 1 * 4; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over( + uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len4 = src_len / 4; + size_t len = (dst_len < src_len4) ? dst_len : src_len4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); + uint32_t s0 = wuffs_private_impl__swap_u32_argb_abgr( + wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( + wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); + + s += 1 * 4; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__rgba_premul__src(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len4 = src_len / 4; + size_t len = (dst_len < src_len4) ? dst_len : src_len4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = wuffs_private_impl__swap_u32_argb_abgr( + wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray(s0); + + s += 1 * 4; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__rgba_premul__src_over(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len4 = src_len / 4; + size_t len = (dst_len < src_len4) ? dst_len : src_len4; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); + uint32_t s0 = wuffs_private_impl__swap_u32_argb_abgr( + wuffs_base__peek_u32le__no_bounds_check(s + (0 * 4))); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( + wuffs_private_impl__composite_premul_premul_u32_axxx(d0, s0)); + + s += 1 * 4; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // wuffs_private_impl__swizzle_y__y_16be(uint8_t* dst_ptr, size_t dst_len, uint8_t* dst_palette_ptr, @@ -26878,6 +28251,8 @@ const uint8_t* s = src_ptr; size_t n = len; + // TODO: unroll. + while (n >= 1) { d[0] = s[0]; @@ -26890,6 +28265,162 @@ } static uint64_t // +wuffs_private_impl__swizzle_y__ya_nonpremul__src(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len2 = src_len / 2; + size_t len = (dst_len < src_len2) ? dst_len : src_len2; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); + d[0] = (uint8_t) + wuffs_base__color_u32_argb_nonpremul__as__color_u32_argb_premul(s0); + + s += 1 * 2; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__ya_nonpremul__src_over(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + size_t src_len2 = src_len / 2; + size_t len = (dst_len < src_len2) ? dst_len : src_len2; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t d0 = 0xFF000000 | ((uint32_t)(d[0]) * 0x010101); + uint32_t s0 = ((uint32_t)(s[1]) << 24) | ((uint32_t)(s[0]) * 0x010101); + d[0] = (uint8_t)wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, + s0); + + s += 1 * 2; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__index__src(uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + if (dst_palette_len != + WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { + return 0; + } + size_t len = (dst_len < src_len) ? dst_len : src_len; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + d[0] = dst_palette_ptr[(size_t)s[0] * 4]; + + s += 1 * 1; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over( + uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + if (dst_palette_len != + WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { + return 0; + } + size_t len = (dst_len < src_len) ? dst_len : src_len; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t d0 = 0xFF000000 | (0x00010101 * ((uint32_t)(d[0]))); + uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + + ((size_t)s[0] * 4)); + d[0] = wuffs_base__color_u32_argb_premul__as__color_u8_gray( + wuffs_private_impl__composite_premul_nonpremul_u32_axxx(d0, s0)); + + s += 1 * 1; + d += 1 * 1; + n -= 1; + } + + return len; +} + +static uint64_t // +wuffs_private_impl__swizzle_y__index_binary_alpha__src_over( + uint8_t* dst_ptr, + size_t dst_len, + uint8_t* dst_palette_ptr, + size_t dst_palette_len, + const uint8_t* src_ptr, + size_t src_len) { + if (dst_palette_len != + WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { + return 0; + } + size_t len = (dst_len < src_len) ? dst_len : src_len; + uint8_t* d = dst_ptr; + const uint8_t* s = src_ptr; + size_t n = len; + + // TODO: unroll. + + while (n >= 1) { + uint32_t s0 = wuffs_base__peek_u32le__no_bounds_check(dst_palette_ptr + + ((size_t)s[0] * 4)); + if (s0) { + d[0] = (uint8_t)s0; + } + + s += 1 * 1; + d += 1 * 1; + n -= 1; + } + + return len; +} + +// -------- + +static uint64_t // wuffs_private_impl__swizzle_y_16le__y_16be(uint8_t* dst_ptr, size_t dst_len, uint8_t* dst_palette_ptr, @@ -27077,6 +28608,15 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__ya_nonpremul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__ya_nonpremul__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__YA_NONPREMUL: switch (blend) { case WUFFS_BASE__PIXEL_BLEND__SRC: @@ -27146,6 +28686,26 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + if (wuffs_private_impl__swizzle_squash_align4_y_8888( + dst_palette.ptr, dst_palette.len, src_palette.ptr, + src_palette.len, true) != + (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { + return NULL; + } + return wuffs_private_impl__swizzle_y__index__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, + src_palette) != + WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH) { + return NULL; + } + return wuffs_private_impl__swizzle_y__index_bgra_nonpremul__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: if (wuffs_private_impl__slice_u8__copy_from_slice(dst_palette, src_palette) != @@ -27318,6 +28878,21 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + if (wuffs_private_impl__swizzle_squash_align4_y_8888( + dst_palette.ptr, dst_palette.len, src_palette.ptr, + src_palette.len, false) != + (WUFFS_BASE__PIXEL_FORMAT__INDEXED__PALETTE_BYTE_LENGTH / 4)) { + return NULL; + } + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__index__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__index_binary_alpha__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_NONPREMUL: case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_PREMUL: case WUFFS_BASE__PIXEL_FORMAT__INDEXED__BGRA_BINARY: @@ -27435,6 +29010,9 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + return wuffs_private_impl__swizzle_y__bgr_565; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: return wuffs_private_impl__swizzle_copy_2_2; @@ -27471,6 +29049,9 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + return wuffs_private_impl__swizzle_y__bgr; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: return wuffs_private_impl__swizzle_bgr_565__bgr; @@ -27624,6 +29205,15 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__bgra_nonpremul_4x16le__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: switch (blend) { case WUFFS_BASE__PIXEL_BLEND__SRC: @@ -27717,6 +29307,15 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__bgra_premul__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: switch (blend) { case WUFFS_BASE__PIXEL_BLEND__SRC: @@ -27798,6 +29397,109 @@ } static inline WUFFS_BASE__FORCE_INLINE wuffs_base__pixel_swizzler__func // +wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( + wuffs_base__pixel_swizzler* p, + wuffs_base__pixel_format dst_pixfmt, + wuffs_base__slice_u8 dst_palette, + wuffs_base__slice_u8 src_palette, + wuffs_base__pixel_blend blend) { + switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr_565__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGR: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_copy_4_4; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL_4X16LE: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul_4x16le__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL: + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_copy_4_4; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_premul__bgra_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGB: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_bgr__rgba_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgr__rgba_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: +#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) + if (wuffs_base__cpu_arch__have_x86_sse42()) { + return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; + } +#endif + return wuffs_private_impl__swizzle_swap_rgbx_bgrx; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_nonpremul__rgba_premul__src_over; + } + return NULL; + + case WUFFS_BASE__PIXEL_FORMAT__RGBA_PREMUL: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: +#if defined(WUFFS_PRIVATE_IMPL__CPU_ARCH__X86_64_V2) + if (wuffs_base__cpu_arch__have_x86_sse42()) { + return wuffs_private_impl__swizzle_swap_rgbx_bgrx__x86_sse42; + } +#endif + return wuffs_private_impl__swizzle_swap_rgbx_bgrx; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_bgra_premul__rgba_premul__src_over; + } + return NULL; + } + return NULL; +} + +static inline WUFFS_BASE__FORCE_INLINE wuffs_base__pixel_swizzler__func // wuffs_private_impl__pixel_swizzler__prepare__bgrx( wuffs_base__pixel_swizzler* p, wuffs_base__pixel_format dst_pixfmt, @@ -27845,6 +29547,9 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + return wuffs_private_impl__swizzle_y__rgb; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: return wuffs_private_impl__swizzle_bgr_565__rgb; @@ -27890,6 +29595,15 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__rgba_nonpremul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__rgba_nonpremul__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: switch (blend) { case WUFFS_BASE__PIXEL_BLEND__SRC: @@ -27988,6 +29702,15 @@ wuffs_base__slice_u8 src_palette, wuffs_base__pixel_blend blend) { switch (dst_pixfmt.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: + switch (blend) { + case WUFFS_BASE__PIXEL_BLEND__SRC: + return wuffs_private_impl__swizzle_y__rgba_premul__src; + case WUFFS_BASE__PIXEL_BLEND__SRC_OVER: + return wuffs_private_impl__swizzle_y__rgba_premul__src_over; + } + return NULL; + case WUFFS_BASE__PIXEL_FORMAT__BGR_565: switch (blend) { case WUFFS_BASE__PIXEL_BLEND__SRC: @@ -28089,6 +29812,10 @@ #if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) switch (dst_pixfmt.repr) { +#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y) + case WUFFS_BASE__PIXEL_FORMAT__Y: + break; +#endif #if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565) case WUFFS_BASE__PIXEL_FORMAT__BGR_565: break; @@ -28215,6 +29942,11 @@ p, dst_pixfmt, dst_palette, src_palette, blend); break; + case WUFFS_BASE__PIXEL_FORMAT__BGRA_BINARY: + func = wuffs_private_impl__pixel_swizzler__prepare__bgra_binary( + p, dst_pixfmt, dst_palette, src_palette, blend); + break; + case WUFFS_BASE__PIXEL_FORMAT__BGRX: func = wuffs_private_impl__pixel_swizzler__prepare__bgrx( p, dst_pixfmt, dst_palette, src_palette, blend); @@ -29669,6 +31401,10 @@ #if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ENABLE_ALLOWLIST) switch (dst->pixcfg.private_impl.pixfmt.repr) { +#if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_Y) + case WUFFS_BASE__PIXEL_FORMAT__Y: + break; +#endif #if defined(WUFFS_CONFIG__DST_PIXEL_FORMAT__ALLOW_BGR_565) case WUFFS_BASE__PIXEL_FORMAT__BGR_565: break; @@ -36060,7 +37796,7 @@ (((uint64_t)(((uint32_t)(WUFFS_CBOR__TOKEN_LENGTHS[v_c_minor])))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); } else { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(787997u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | + (((uint64_t)(731642u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | (((uint64_t)(16777216u)) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(9u)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); } @@ -36284,12 +38020,12 @@ } if (v_string_length < 262144u) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(787997u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | + (((uint64_t)(731642u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | (((uint64_t)((4194304u | ((uint32_t)(v_string_length))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(((uint32_t)(WUFFS_CBOR__TOKEN_LENGTHS[v_c_minor])))) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); } else { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(787997u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | + (((uint64_t)(731642u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | (((uint64_t)((4194304u | ((uint32_t)((v_string_length >> 46u)))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1u)) << WUFFS_BASE__TOKEN__CONTINUED__SHIFT) | (((uint64_t)(0u)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); @@ -36302,7 +38038,7 @@ } else if (v_c_major == 7u) { if (v_c_minor < 20u) { *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(787997u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | + (((uint64_t)(731642u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | (((uint64_t)((8388608u | ((uint32_t)((v_string_length & 255u)))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(1u)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); goto label__goto_parsed_a_leaf_value__break; @@ -36321,7 +38057,7 @@ break; } *iop_a_dst++ = wuffs_base__make_token( - (((uint64_t)(787997u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | + (((uint64_t)(731642u)) << WUFFS_BASE__TOKEN__VALUE_MAJOR__SHIFT) | (((uint64_t)((8388608u | ((uint32_t)((v_string_length & 255u)))))) << WUFFS_BASE__TOKEN__VALUE_MINOR__SHIFT) | (((uint64_t)(2u)) << WUFFS_BASE__TOKEN__LENGTH__SHIFT)); goto label__goto_parsed_a_leaf_value__break; @@ -40619,6 +42355,1908 @@ #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__DEFLATE) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) + +// ---------------- Status Codes Implementations + +const char wuffs_etc2__error__bad_header[] = "#etc2: bad header"; +const char wuffs_etc2__error__truncated_input[] = "#etc2: truncated input"; +const char wuffs_etc2__error__unsupported_etc2_file[] = "#etc2: unsupported ETC2 file"; + +// ---------------- Private Consts + +static const uint32_t +WUFFS_ETC2__DIFFS[8] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0u, 1u, 2u, 3u, 4294967292u, 4294967293u, 4294967294u, 4294967295u, +}; + +static const uint32_t +WUFFS_ETC2__MODIFIERS[16][4] WUFFS_BASE__POTENTIALLY_UNUSED = { + { + 2u, 8u, 4294967294u, 4294967288u, + }, { + 5u, 17u, 4294967291u, 4294967279u, + }, { + 9u, 29u, 4294967287u, 4294967267u, + }, { + 13u, 42u, 4294967283u, 4294967254u, + }, { + 18u, 60u, 4294967278u, 4294967236u, + }, { + 24u, 80u, 4294967272u, 4294967216u, + }, { + 33u, 106u, 4294967263u, 4294967190u, + }, { + 47u, 183u, 4294967249u, 4294967113u, + }, + { + 0u, 8u, 0u, 4294967288u, + }, { + 0u, 17u, 0u, 4294967279u, + }, { + 0u, 29u, 0u, 4294967267u, + }, { + 0u, 42u, 0u, 4294967254u, + }, { + 0u, 60u, 0u, 4294967236u, + }, { + 0u, 80u, 0u, 4294967216u, + }, { + 0u, 106u, 0u, 4294967190u, + }, { + 0u, 183u, 0u, 4294967113u, + }, +}; + +static const uint8_t +WUFFS_ETC2__T_H_MODIFIERS[8] WUFFS_BASE__POTENTIALLY_UNUSED = { + 3u, 6u, 11u, 16u, 23u, 32u, 41u, 64u, +}; + +static const uint32_t +WUFFS_ETC2__ALPHA_MODIFIERS[16][8] WUFFS_BASE__POTENTIALLY_UNUSED = { + { + 4294967293u, 4294967290u, 4294967287u, 4294967281u, 2u, 5u, 8u, 14u, + }, { + 4294967293u, 4294967289u, 4294967286u, 4294967283u, 2u, 6u, 9u, 12u, + }, { + 4294967294u, 4294967291u, 4294967288u, 4294967283u, 1u, 4u, 7u, 12u, + }, { + 4294967294u, 4294967292u, 4294967290u, 4294967283u, 1u, 3u, 5u, 12u, + }, { + 4294967293u, 4294967290u, 4294967288u, 4294967284u, 2u, 5u, 7u, 11u, + }, { + 4294967293u, 4294967289u, 4294967287u, 4294967285u, 2u, 6u, 8u, 10u, + }, { + 4294967292u, 4294967289u, 4294967288u, 4294967285u, 3u, 6u, 7u, 10u, + }, { + 4294967293u, 4294967291u, 4294967288u, 4294967285u, 2u, 4u, 7u, 10u, + }, + { + 4294967294u, 4294967290u, 4294967288u, 4294967286u, 1u, 5u, 7u, 9u, + }, { + 4294967294u, 4294967291u, 4294967288u, 4294967286u, 1u, 4u, 7u, 9u, + }, { + 4294967294u, 4294967292u, 4294967288u, 4294967286u, 1u, 3u, 7u, 9u, + }, { + 4294967294u, 4294967291u, 4294967289u, 4294967286u, 1u, 4u, 6u, 9u, + }, { + 4294967293u, 4294967292u, 4294967289u, 4294967286u, 2u, 3u, 6u, 9u, + }, { + 4294967295u, 4294967294u, 4294967293u, 4294967286u, 0u, 1u, 2u, 9u, + }, { + 4294967292u, 4294967290u, 4294967288u, 4294967287u, 3u, 5u, 7u, 8u, + }, { + 4294967293u, 4294967291u, 4294967289u, 4294967287u, 2u, 4u, 6u, 8u, + }, +}; + +static const uint8_t +WUFFS_ETC2__CLAMP[1024] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, + 8u, 9u, 10u, 11u, 12u, 13u, 14u, 15u, + 16u, 17u, 18u, 19u, 20u, 21u, 22u, 23u, + 24u, 25u, 26u, 27u, 28u, 29u, 30u, 31u, + 32u, 33u, 34u, 35u, 36u, 37u, 38u, 39u, + 40u, 41u, 42u, 43u, 44u, 45u, 46u, 47u, + 48u, 49u, 50u, 51u, 52u, 53u, 54u, 55u, + 56u, 57u, 58u, 59u, 60u, 61u, 62u, 63u, + 64u, 65u, 66u, 67u, 68u, 69u, 70u, 71u, + 72u, 73u, 74u, 75u, 76u, 77u, 78u, 79u, + 80u, 81u, 82u, 83u, 84u, 85u, 86u, 87u, + 88u, 89u, 90u, 91u, 92u, 93u, 94u, 95u, + 96u, 97u, 98u, 99u, 100u, 101u, 102u, 103u, + 104u, 105u, 106u, 107u, 108u, 109u, 110u, 111u, + 112u, 113u, 114u, 115u, 116u, 117u, 118u, 119u, + 120u, 121u, 122u, 123u, 124u, 125u, 126u, 127u, + 128u, 129u, 130u, 131u, 132u, 133u, 134u, 135u, + 136u, 137u, 138u, 139u, 140u, 141u, 142u, 143u, + 144u, 145u, 146u, 147u, 148u, 149u, 150u, 151u, + 152u, 153u, 154u, 155u, 156u, 157u, 158u, 159u, + 160u, 161u, 162u, 163u, 164u, 165u, 166u, 167u, + 168u, 169u, 170u, 171u, 172u, 173u, 174u, 175u, + 176u, 177u, 178u, 179u, 180u, 181u, 182u, 183u, + 184u, 185u, 186u, 187u, 188u, 189u, 190u, 191u, + 192u, 193u, 194u, 195u, 196u, 197u, 198u, 199u, + 200u, 201u, 202u, 203u, 204u, 205u, 206u, 207u, + 208u, 209u, 210u, 211u, 212u, 213u, 214u, 215u, + 216u, 217u, 218u, 219u, 220u, 221u, 222u, 223u, + 224u, 225u, 226u, 227u, 228u, 229u, 230u, 231u, + 232u, 233u, 234u, 235u, 236u, 237u, 238u, 239u, + 240u, 241u, 242u, 243u, 244u, 245u, 246u, 247u, + 248u, 249u, 250u, 251u, 252u, 253u, 254u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 255u, 255u, 255u, 255u, 255u, 255u, 255u, 255u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, +}; + +// ---------------- Private Initializer Prototypes + +// ---------------- Private Function Prototypes + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__do_decode_image_config( + wuffs_etc2__decoder* self, + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__do_decode_frame_config( + wuffs_etc2__decoder* self, + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__do_decode_frame( + wuffs_etc2__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__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__from_src_to_colors( + wuffs_etc2__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__from_colors_to_buffer( + wuffs_etc2__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_t_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset, + bool a_transparent); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_h_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset, + bool a_transparent); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_planar_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_half_block( + wuffs_etc2__decoder* self, + uint32_t a_bits, + uint32_t a_offset, + uint32_t a_which, + uint32_t a_r, + uint32_t a_g, + uint32_t a_b, + bool a_flip, + bool a_transparent, + bool a_second); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__from_alphas_to_buffer( + wuffs_etc2__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__from_buffer_to_dst( + wuffs_etc2__decoder* self, + wuffs_base__pixel_buffer* a_dst); + +// ---------------- VTables + +const wuffs_base__image_decoder__func_ptrs +wuffs_etc2__decoder__func_ptrs_for__wuffs_base__image_decoder = { + (wuffs_base__status(*)(void*, + wuffs_base__pixel_buffer*, + wuffs_base__io_buffer*, + wuffs_base__pixel_blend, + wuffs_base__slice_u8, + wuffs_base__decode_frame_options*))(&wuffs_etc2__decoder__decode_frame), + (wuffs_base__status(*)(void*, + wuffs_base__frame_config*, + wuffs_base__io_buffer*))(&wuffs_etc2__decoder__decode_frame_config), + (wuffs_base__status(*)(void*, + wuffs_base__image_config*, + wuffs_base__io_buffer*))(&wuffs_etc2__decoder__decode_image_config), + (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_etc2__decoder__frame_dirty_rect), + (uint64_t(*)(const void*, + uint32_t))(&wuffs_etc2__decoder__get_quirk), + (uint32_t(*)(const void*))(&wuffs_etc2__decoder__num_animation_loops), + (uint64_t(*)(const void*))(&wuffs_etc2__decoder__num_decoded_frame_configs), + (uint64_t(*)(const void*))(&wuffs_etc2__decoder__num_decoded_frames), + (wuffs_base__status(*)(void*, + uint64_t, + uint64_t))(&wuffs_etc2__decoder__restart_frame), + (wuffs_base__status(*)(void*, + uint32_t, + uint64_t))(&wuffs_etc2__decoder__set_quirk), + (wuffs_base__empty_struct(*)(void*, + uint32_t, + bool))(&wuffs_etc2__decoder__set_report_metadata), + (wuffs_base__status(*)(void*, + wuffs_base__io_buffer*, + wuffs_base__more_information*, + wuffs_base__io_buffer*))(&wuffs_etc2__decoder__tell_me_more), + (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_etc2__decoder__workbuf_len), +}; + +// ---------------- Initializer Implementations + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT +wuffs_etc2__decoder__initialize( + wuffs_etc2__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options){ + if (!self) { + return wuffs_base__make_status(wuffs_base__error__bad_receiver); + } + if (sizeof(*self) != sizeof_star_self) { + return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver); + } + if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || + (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { + return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); + } + + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + // The whole point of this if-check is to detect an uninitialized *self. + // We disable the warning on GCC. Clang-5.0 does not have this warning. +#if !defined(__clang__) && defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif + if (self->private_impl.magic != 0) { + return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed); + } +#if !defined(__clang__) && defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + memset(self, 0, sizeof(*self)); + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; + } else { + memset(&(self->private_impl), 0, sizeof(self->private_impl)); + } + } + + self->private_impl.magic = WUFFS_BASE__MAGIC; + self->private_impl.vtable_for__wuffs_base__image_decoder.vtable_name = + wuffs_base__image_decoder__vtable_name; + self->private_impl.vtable_for__wuffs_base__image_decoder.function_pointers = + (const void*)(&wuffs_etc2__decoder__func_ptrs_for__wuffs_base__image_decoder); + return wuffs_base__make_status(NULL); +} + +wuffs_etc2__decoder* +wuffs_etc2__decoder__alloc(void) { + wuffs_etc2__decoder* x = + (wuffs_etc2__decoder*)(calloc(1, sizeof(wuffs_etc2__decoder))); + if (!x) { + return NULL; + } + if (wuffs_etc2__decoder__initialize( + x, sizeof(wuffs_etc2__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) { + free(x); + return NULL; + } + return x; +} + +size_t +sizeof__wuffs_etc2__decoder(void) { + return sizeof(wuffs_etc2__decoder); +} + +// ---------------- Function Implementations + +// -------- func etc2.decoder.get_quirk + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_etc2__decoder__get_quirk( + const wuffs_etc2__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 etc2.decoder.set_quirk + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__set_quirk( + wuffs_etc2__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 etc2.decoder.decode_image_config + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__decode_image_config( + wuffs_etc2__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_etc2__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_etc2__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 etc2.decoder.do_decode_image_config + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__do_decode_image_config( + wuffs_etc2__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; + uint16_t v_rounded_up_width = 0; + uint16_t v_rounded_up_height = 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; + if (coro_susp_point) { + v_rounded_up_width = self->private_data.s_do_decode_image_config.v_rounded_up_width; + v_rounded_up_height = self->private_data.s_do_decode_image_config.v_rounded_up_height; + } + 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 != 541936464u) { + status = wuffs_base__make_status(wuffs_etc2__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; + } + } + v_c32 = t_1; + } + if ((v_c32 == 12337u) || (v_c32 == 16789554u) || (v_c32 == 151007282u)) { + self->private_impl.f_pixfmt = 2415954056u; + } else if ((v_c32 == 50343986u) || (v_c32 == 167784498u)) { + self->private_impl.f_pixfmt = 2164295816u; + } else if ((v_c32 == 67121202u) || (v_c32 == 184561714u)) { + self->private_impl.f_pixfmt = 2197850248u; + } else if ((v_c32 & 65535u) == 12338u) { + status = wuffs_base__make_status(wuffs_etc2__error__unsupported_etc2_file); + goto exit; + } else { + status = wuffs_base__make_status(wuffs_etc2__error__bad_header); + goto exit; + } + self->private_impl.f_srgb = ((v_c32 >> 24u) >= 9u); + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + uint16_t t_2; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { + t_2 = wuffs_base__peek_u16be__no_bounds_check(iop_a_src); + iop_a_src += 2; + } else { + self->private_data.s_do_decode_image_config.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.scratch; + uint32_t num_bits_2 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_2); + if (num_bits_2 == 8) { + t_2 = ((uint16_t)(*scratch >> 48)); + break; + } + num_bits_2 += 8u; + *scratch |= ((uint64_t)(num_bits_2)); + } + } + v_rounded_up_width = t_2; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + uint16_t t_3; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { + t_3 = wuffs_base__peek_u16be__no_bounds_check(iop_a_src); + iop_a_src += 2; + } else { + self->private_data.s_do_decode_image_config.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + 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_3 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_3); + if (num_bits_3 == 8) { + t_3 = ((uint16_t)(*scratch >> 48)); + break; + } + num_bits_3 += 8u; + *scratch |= ((uint64_t)(num_bits_3)); + } + } + v_rounded_up_height = t_3; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + uint32_t t_4; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { + t_4 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src))); + iop_a_src += 2; + } else { + self->private_data.s_do_decode_image_config.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); + 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_4 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_4); + if (num_bits_4 == 8) { + t_4 = ((uint32_t)(*scratch >> 48)); + break; + } + num_bits_4 += 8u; + *scratch |= ((uint64_t)(num_bits_4)); + } + } + v_c32 = t_4; + } + if (((v_c32 + 3u) & 4294967292u) != ((uint32_t)(v_rounded_up_width))) { + status = wuffs_base__make_status(wuffs_etc2__error__bad_header); + goto exit; + } + self->private_impl.f_width = v_c32; + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); + uint32_t t_5; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { + t_5 = ((uint32_t)(wuffs_base__peek_u16be__no_bounds_check(iop_a_src))); + iop_a_src += 2; + } else { + self->private_data.s_do_decode_image_config.scratch = 0; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); + 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_5 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_5); + if (num_bits_5 == 8) { + t_5 = ((uint32_t)(*scratch >> 48)); + break; + } + num_bits_5 += 8u; + *scratch |= ((uint64_t)(num_bits_5)); + } + } + v_c32 = t_5; + } + if (((v_c32 + 3u) & 4294967292u) != ((uint32_t)(v_rounded_up_height))) { + status = wuffs_base__make_status(wuffs_etc2__error__bad_header); + goto exit; + } + self->private_impl.f_height = v_c32; + if (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, + 16u, + (self->private_impl.f_pixfmt == 2415954056u)); + } + self->private_impl.f_call_sequence = 32u; + + goto ok; + 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; + self->private_data.s_do_decode_image_config.v_rounded_up_width = v_rounded_up_width; + self->private_data.s_do_decode_image_config.v_rounded_up_height = v_rounded_up_height; + + 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 etc2.decoder.decode_frame_config + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__decode_frame_config( + wuffs_etc2__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) { + { + wuffs_base__status t_0 = wuffs_etc2__decoder__do_decode_frame_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_etc2__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 etc2.decoder.do_decode_frame_config + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__do_decode_frame_config( + wuffs_etc2__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_etc2__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 (16u != 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) { + 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, + 16u, + 0u, + (self->private_impl.f_pixfmt == 2415954056u), + false, + 4278190080u); + } + 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 etc2.decoder.decode_frame + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__decode_frame( + wuffs_etc2__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_etc2__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_etc2__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 etc2.decoder.do_decode_frame + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__do_decode_frame( + wuffs_etc2__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); + + uint32_t v_remaining = 0; + wuffs_base__status v_status = wuffs_base__make_status(NULL); + + uint32_t coro_susp_point = self->private_impl.p_do_decode_frame; + if (coro_susp_point) { + v_remaining = self->private_data.s_do_decode_frame.v_remaining; + } + 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) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_etc2__decoder__do_decode_frame_config(self, NULL, a_src); + if (status.repr) { + goto suspend; + } + } else { + status = wuffs_base__make_status(wuffs_base__note__end_of_data); + goto ok; + } + 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(a_dst), + wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt), + wuffs_base__utility__empty_slice_u8(), + a_blend); + 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; + } + self->private_impl.f_dst_x = 0u; + self->private_impl.f_dst_y = 0u; + v_remaining = (((self->private_impl.f_width + 3u) / 4u) * ((self->private_impl.f_height + 3u) / 4u)); + while (v_remaining > 0u) { + self->private_impl.f_num_buffered_blocks = wuffs_base__u32__min(v_remaining, 64u); + if (v_remaining < self->private_impl.f_num_buffered_blocks) { + status = wuffs_base__make_status(wuffs_base__error__too_much_data); + goto exit; + } + v_remaining -= self->private_impl.f_num_buffered_blocks; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + status = wuffs_etc2__decoder__from_src_to_colors(self, a_src); + if (status.repr) { + goto suspend; + } + wuffs_etc2__decoder__from_colors_to_buffer(self); + if (self->private_impl.f_pixfmt == 2164295816u) { + wuffs_etc2__decoder__from_alphas_to_buffer(self); + } + v_status = wuffs_etc2__decoder__from_buffer_to_dst(self, a_dst); + 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; + } + } + self->private_impl.f_call_sequence = 96u; + + 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; + self->private_data.s_do_decode_frame.v_remaining = v_remaining; + + goto exit; + exit: + return status; +} + +// -------- func etc2.decoder.from_src_to_colors + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__from_src_to_colors( + wuffs_etc2__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint32_t v_bi = 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_from_src_to_colors; + if (coro_susp_point) { + v_bi = self->private_data.s_from_src_to_colors.v_bi; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + while (v_bi < self->private_impl.f_num_buffered_blocks) { + if (self->private_impl.f_pixfmt == 2164295816u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + uint64_t t_0; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { + t_0 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); + iop_a_src += 8; + } else { + self->private_data.s_from_src_to_colors.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_from_src_to_colors.scratch; + uint32_t num_bits_0 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_0); + if (num_bits_0 == 56) { + t_0 = ((uint64_t)(*scratch >> 0)); + break; + } + num_bits_0 += 8u; + *scratch |= ((uint64_t)(num_bits_0)); + } + } + self->private_data.f_alphas[v_bi] = t_0; + } + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + uint64_t t_1; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 8)) { + t_1 = wuffs_base__peek_u64be__no_bounds_check(iop_a_src); + iop_a_src += 8; + } else { + self->private_data.s_from_src_to_colors.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_from_src_to_colors.scratch; + uint32_t num_bits_1 = ((uint32_t)(*scratch & 0xFFu)); + *scratch >>= 8; + *scratch <<= 8; + *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_1); + if (num_bits_1 == 56) { + t_1 = ((uint64_t)(*scratch >> 0)); + break; + } + num_bits_1 += 8u; + *scratch |= ((uint64_t)(num_bits_1)); + } + } + self->private_data.f_colors[v_bi] = t_1; + } + v_bi += 1u; + } + + goto ok; + ok: + self->private_impl.p_from_src_to_colors = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_from_src_to_colors = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_from_src_to_colors.v_bi = v_bi; + + 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 etc2.decoder.from_colors_to_buffer + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__from_colors_to_buffer( + wuffs_etc2__decoder* self) { + uint32_t v_bi = 0; + uint64_t v_color = 0; + uint32_t v_r0 = 0; + uint32_t v_r1 = 0; + uint32_t v_g0 = 0; + uint32_t v_g1 = 0; + uint32_t v_b0 = 0; + uint32_t v_b1 = 0; + bool v_diff = false; + bool v_tran = false; + bool v_flip = false; + + while (v_bi < self->private_impl.f_num_buffered_blocks) { + v_color = self->private_data.f_colors[v_bi]; + v_diff = ((v_color & 8589934592u) != 0u); + v_tran = ( ! v_diff && (self->private_impl.f_pixfmt == 2197850248u)); + if ( ! v_diff && (self->private_impl.f_pixfmt != 2197850248u)) { + v_r0 = ((uint32_t)((15u & (v_color >> 60u)))); + v_r0 = ((v_r0 << 4u) | v_r0); + v_r1 = ((uint32_t)((15u & (v_color >> 56u)))); + v_r1 = ((v_r1 << 4u) | v_r1); + v_g0 = ((uint32_t)((15u & (v_color >> 52u)))); + v_g0 = ((v_g0 << 4u) | v_g0); + v_g1 = ((uint32_t)((15u & (v_color >> 48u)))); + v_g1 = ((v_g1 << 4u) | v_g1); + v_b0 = ((uint32_t)((15u & (v_color >> 44u)))); + v_b0 = ((v_b0 << 4u) | v_b0); + v_b1 = ((uint32_t)((15u & (v_color >> 40u)))); + v_b1 = ((v_b1 << 4u) | v_b1); + } else { + v_r0 = ((uint32_t)((31u & (v_color >> 59u)))); + v_r1 = ((uint32_t)(v_r0 + WUFFS_ETC2__DIFFS[(7u & (v_color >> 56u))])); + if ((v_r1 >> 5u) != 0u) { + wuffs_etc2__decoder__decode_t_mode(self, v_color, (16u * v_bi), v_tran); + v_bi += 1u; + continue; + } + v_r0 = (((uint32_t)(v_r0 << 3u)) | (v_r0 >> 2u)); + v_r1 = (((uint32_t)(v_r1 << 3u)) | (v_r1 >> 2u)); + v_g0 = ((uint32_t)((31u & (v_color >> 51u)))); + v_g1 = ((uint32_t)(v_g0 + WUFFS_ETC2__DIFFS[(7u & (v_color >> 48u))])); + if ((v_g1 >> 5u) != 0u) { + wuffs_etc2__decoder__decode_h_mode(self, v_color, (16u * v_bi), v_tran); + v_bi += 1u; + continue; + } + v_g0 = (((uint32_t)(v_g0 << 3u)) | (v_g0 >> 2u)); + v_g1 = (((uint32_t)(v_g1 << 3u)) | (v_g1 >> 2u)); + v_b0 = ((uint32_t)((31u & (v_color >> 43u)))); + v_b1 = ((uint32_t)(v_b0 + WUFFS_ETC2__DIFFS[(7u & (v_color >> 40u))])); + if ((v_b1 >> 5u) != 0u) { + wuffs_etc2__decoder__decode_planar_mode(self, v_color, (16u * v_bi)); + v_bi += 1u; + continue; + } + v_b0 = (((uint32_t)(v_b0 << 3u)) | (v_b0 >> 2u)); + v_b1 = (((uint32_t)(v_b1 << 3u)) | (v_b1 >> 2u)); + } + v_flip = ((v_color & 4294967296u) != 0u); + wuffs_etc2__decoder__decode_half_block(self, + ((uint32_t)(v_color)), + (16u * v_bi), + ((uint32_t)(((v_color >> 37u) & 7u))), + v_r0, + v_g0, + v_b0, + v_flip, + v_tran, + false); + wuffs_etc2__decoder__decode_half_block(self, + ((uint32_t)(v_color)), + (16u * v_bi), + ((uint32_t)(((v_color >> 34u) & 7u))), + v_r1, + v_g1, + v_b1, + v_flip, + v_tran, + true); + v_bi += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.decode_t_mode + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_t_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset, + bool a_transparent) { + uint8_t v_r[4] = {0}; + uint8_t v_g[4] = {0}; + uint8_t v_b[4] = {0}; + uint8_t v_a[4] = {0}; + uint32_t v_which = 0; + uint32_t v_delta = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_x4y = 0; + uint32_t v_index = 0; + uint32_t v_o = 0; + + v_r[0u] = ((uint8_t)(((uint8_t)((12u & (a_bits >> 57u)))) | ((uint8_t)((3u & (a_bits >> 56u)))))); + v_r[0u] = ((uint8_t)(((uint8_t)(v_r[0u] << 4u)) | v_r[0u])); + v_g[0u] = ((uint8_t)((15u & (a_bits >> 52u)))); + v_g[0u] = ((uint8_t)(((uint8_t)(v_g[0u] << 4u)) | v_g[0u])); + v_b[0u] = ((uint8_t)((15u & (a_bits >> 48u)))); + v_b[0u] = ((uint8_t)(((uint8_t)(v_b[0u] << 4u)) | v_b[0u])); + v_a[0u] = 255u; + v_r[2u] = ((uint8_t)((15u & (a_bits >> 44u)))); + v_r[2u] = ((uint8_t)(((uint8_t)(v_r[2u] << 4u)) | v_r[2u])); + v_g[2u] = ((uint8_t)((15u & (a_bits >> 40u)))); + v_g[2u] = ((uint8_t)(((uint8_t)(v_g[2u] << 4u)) | v_g[2u])); + v_b[2u] = ((uint8_t)((15u & (a_bits >> 36u)))); + v_b[2u] = ((uint8_t)(((uint8_t)(v_b[2u] << 4u)) | v_b[2u])); + v_a[2u] = 255u; + v_which = (((uint32_t)((6u & (a_bits >> 33u)))) | ((uint32_t)((1u & (a_bits >> 32u))))); + v_delta = ((uint32_t)(WUFFS_ETC2__T_H_MODIFIERS[v_which])); + v_r[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) + v_delta)) & 1023u)]; + v_g[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) + v_delta)) & 1023u)]; + v_b[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) + v_delta)) & 1023u)]; + v_a[1u] = 255u; + v_r[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) - v_delta)) & 1023u)]; + v_g[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) - v_delta)) & 1023u)]; + v_b[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) - v_delta)) & 1023u)]; + v_a[3u] = 255u; + if (a_transparent) { + v_r[2u] = 0u; + v_g[2u] = 0u; + v_b[2u] = 0u; + v_a[2u] = 0u; + } + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_x4y = ((v_x * 4u) | v_y); + v_index = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + self->private_data.f_buffer[(v_o + 0u)] = v_b[v_index]; + self->private_data.f_buffer[(v_o + 1u)] = v_g[v_index]; + self->private_data.f_buffer[(v_o + 2u)] = v_r[v_index]; + self->private_data.f_buffer[(v_o + 3u)] = v_a[v_index]; + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.decode_h_mode + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_h_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset, + bool a_transparent) { + uint8_t v_r[4] = {0}; + uint8_t v_g[4] = {0}; + uint8_t v_b[4] = {0}; + uint8_t v_a[4] = {0}; + uint32_t v_rgb0 = 0; + uint32_t v_rgb2 = 0; + uint32_t v_which = 0; + uint32_t v_delta = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_x4y = 0; + uint32_t v_index = 0; + uint32_t v_o = 0; + + v_r[0u] = ((uint8_t)((15u & (a_bits >> 59u)))); + v_r[0u] = ((uint8_t)(((uint8_t)(v_r[0u] << 4u)) | v_r[0u])); + v_g[0u] = ((uint8_t)(((uint8_t)((14u & (a_bits >> 55u)))) | ((uint8_t)((1u & (a_bits >> 52u)))))); + v_g[0u] = ((uint8_t)(((uint8_t)(v_g[0u] << 4u)) | v_g[0u])); + v_b[0u] = ((uint8_t)(((uint8_t)((8u & (a_bits >> 48u)))) | ((uint8_t)((7u & (a_bits >> 47u)))))); + v_b[0u] = ((uint8_t)(((uint8_t)(v_b[0u] << 4u)) | v_b[0u])); + v_r[2u] = ((uint8_t)((15u & (a_bits >> 43u)))); + v_r[2u] = ((uint8_t)(((uint8_t)(v_r[2u] << 4u)) | v_r[2u])); + v_g[2u] = ((uint8_t)((15u & (a_bits >> 39u)))); + v_g[2u] = ((uint8_t)(((uint8_t)(v_g[2u] << 4u)) | v_g[2u])); + v_b[2u] = ((uint8_t)((15u & (a_bits >> 35u)))); + v_b[2u] = ((uint8_t)(((uint8_t)(v_b[2u] << 4u)) | v_b[2u])); + v_rgb0 = ((((uint32_t)(v_r[0u])) << 16u) | (((uint32_t)(v_g[0u])) << 8u) | (((uint32_t)(v_b[0u])) << 0u)); + v_rgb2 = ((((uint32_t)(v_r[2u])) << 16u) | (((uint32_t)(v_g[2u])) << 8u) | (((uint32_t)(v_b[2u])) << 0u)); + v_which = (((uint32_t)((4u & (a_bits >> 32u)))) | ((uint32_t)((2u & (a_bits >> 31u))))); + if (v_rgb0 >= v_rgb2) { + v_which |= 1u; + } + v_delta = ((uint32_t)(WUFFS_ETC2__T_H_MODIFIERS[v_which])); + v_r[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[0u])) - v_delta)) & 1023u)]; + v_g[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[0u])) - v_delta)) & 1023u)]; + v_b[1u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[0u])) - v_delta)) & 1023u)]; + v_a[1u] = 255u; + v_r[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[0u])) + v_delta)) & 1023u)]; + v_g[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[0u])) + v_delta)) & 1023u)]; + v_b[0u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[0u])) + v_delta)) & 1023u)]; + v_a[0u] = 255u; + v_r[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) - v_delta)) & 1023u)]; + v_g[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) - v_delta)) & 1023u)]; + v_b[3u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) - v_delta)) & 1023u)]; + v_a[3u] = 255u; + v_r[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_r[2u])) + v_delta)) & 1023u)]; + v_g[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_g[2u])) + v_delta)) & 1023u)]; + v_b[2u] = WUFFS_ETC2__CLAMP[(((uint32_t)(((uint32_t)(v_b[2u])) + v_delta)) & 1023u)]; + v_a[2u] = 255u; + if (a_transparent) { + v_r[2u] = 0u; + v_g[2u] = 0u; + v_b[2u] = 0u; + v_a[2u] = 0u; + } + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_x4y = ((v_x * 4u) | v_y); + v_index = (((uint32_t)(((a_bits >> v_x4y) & 1u))) | ((uint32_t)(((a_bits >> (v_x4y + 15u)) & 2u)))); + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + self->private_data.f_buffer[(v_o + 0u)] = v_b[v_index]; + self->private_data.f_buffer[(v_o + 1u)] = v_g[v_index]; + self->private_data.f_buffer[(v_o + 2u)] = v_r[v_index]; + self->private_data.f_buffer[(v_o + 3u)] = v_a[v_index]; + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.decode_planar_mode + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_planar_mode( + wuffs_etc2__decoder* self, + uint64_t a_bits, + uint32_t a_offset) { + uint32_t v_ro = 0; + uint32_t v_go = 0; + uint32_t v_bo = 0; + uint32_t v_rh = 0; + uint32_t v_gh = 0; + uint32_t v_bh = 0; + uint32_t v_rv = 0; + uint32_t v_gv = 0; + uint32_t v_bv = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_o = 0; + uint32_t v_rp = 0; + uint32_t v_gp = 0; + uint32_t v_bp = 0; + + v_ro = ((uint32_t)((63u & (a_bits >> 57u)))); + v_ro = (((uint32_t)(v_ro << 2u)) | (v_ro >> 4u)); + v_go = (((uint32_t)((64u & (a_bits >> 50u)))) | ((uint32_t)((63u & (a_bits >> 49u))))); + v_go = (((uint32_t)(v_go << 1u)) | (v_go >> 6u)); + v_bo = (((uint32_t)((32u & (a_bits >> 43u)))) | ((uint32_t)((24u & (a_bits >> 40u)))) | ((uint32_t)((7u & (a_bits >> 39u))))); + v_bo = (((uint32_t)(v_bo << 2u)) | (v_bo >> 4u)); + v_rh = (((uint32_t)((62u & (a_bits >> 33u)))) | ((uint32_t)((1u & (a_bits >> 32u))))); + v_rh = (((uint32_t)(v_rh << 2u)) | (v_rh >> 4u)); + v_gh = ((uint32_t)((127u & (a_bits >> 25u)))); + v_gh = (((uint32_t)(v_gh << 1u)) | (v_gh >> 6u)); + v_bh = ((uint32_t)((63u & (a_bits >> 19u)))); + v_bh = (((uint32_t)(v_bh << 2u)) | (v_bh >> 4u)); + v_rv = ((uint32_t)((63u & (a_bits >> 13u)))); + v_rv = (((uint32_t)(v_rv << 2u)) | (v_rv >> 4u)); + v_gv = ((uint32_t)((127u & (a_bits >> 6u)))); + v_gv = (((uint32_t)(v_gv << 1u)) | (v_gv >> 6u)); + v_bv = ((uint32_t)((63u & (a_bits >> 0u)))); + v_bv = (((uint32_t)(v_bv << 2u)) | (v_bv >> 4u)); + v_rh -= v_ro; + v_gh -= v_go; + v_bh -= v_bo; + v_rv -= v_ro; + v_gv -= v_go; + v_bv -= v_bo; + v_ro *= 4u; + v_go *= 4u; + v_bo *= 4u; + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + v_bp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_bh)) + ((uint32_t)(v_y * v_bv)))) + v_bo)); + self->private_data.f_buffer[(v_o + 0u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_bp + 2u)) / 4u) & 1023u)]; + v_gp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_gh)) + ((uint32_t)(v_y * v_gv)))) + v_go)); + self->private_data.f_buffer[(v_o + 1u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_gp + 2u)) / 4u) & 1023u)]; + v_rp = ((uint32_t)(((uint32_t)(((uint32_t)(v_x * v_rh)) + ((uint32_t)(v_y * v_rv)))) + v_ro)); + self->private_data.f_buffer[(v_o + 2u)] = WUFFS_ETC2__CLAMP[((((uint32_t)(v_rp + 2u)) / 4u) & 1023u)]; + v_x += 1u; + self->private_data.f_buffer[(v_o + 3u)] = 255u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.decode_half_block + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__decode_half_block( + wuffs_etc2__decoder* self, + uint32_t a_bits, + uint32_t a_offset, + uint32_t a_which, + uint32_t a_r, + uint32_t a_g, + uint32_t a_b, + bool a_flip, + bool a_transparent, + bool a_second) { + uint32_t v_which = 0; + uint32_t v_x0 = 0; + uint32_t v_y0 = 0; + uint32_t v_x = 0; + uint32_t v_y = 0; + uint32_t v_i = 0; + uint32_t v_x4y = 0; + uint32_t v_index = 0; + uint32_t v_modif = 0; + uint32_t v_o = 0; + + v_which = a_which; + if (a_transparent) { + v_which |= 8u; + } + if ( ! a_second) { + } else if (a_flip) { + v_y0 = 2u; + } else { + v_x0 = 2u; + } + while (v_i < 8u) { + if (a_flip) { + v_x = ((v_x0 + (v_i / 2u)) & 3u); + v_y = (v_y0 + (v_i & 1u)); + } else { + v_x = (v_x0 + (v_i / 4u)); + v_y = ((v_y0 + v_i) & 3u); + } + v_x4y = ((v_x * 4u) | v_y); + v_index = (((a_bits >> v_x4y) & 1u) | ((a_bits >> (v_x4y + 15u)) & 2u)); + v_modif = WUFFS_ETC2__MODIFIERS[v_which][v_index]; + v_o = (a_offset + (v_x * 4u) + (v_y * 1024u)); + if (a_transparent && (v_index == 2u)) { + self->private_data.f_buffer[(v_o + 0u)] = 0u; + self->private_data.f_buffer[(v_o + 1u)] = 0u; + self->private_data.f_buffer[(v_o + 2u)] = 0u; + self->private_data.f_buffer[(v_o + 3u)] = 0u; + } else { + self->private_data.f_buffer[(v_o + 0u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_b + v_modif)) & 1023u)]; + self->private_data.f_buffer[(v_o + 1u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_g + v_modif)) & 1023u)]; + self->private_data.f_buffer[(v_o + 2u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(a_r + v_modif)) & 1023u)]; + self->private_data.f_buffer[(v_o + 3u)] = 255u; + } + v_i += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.from_alphas_to_buffer + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_etc2__decoder__from_alphas_to_buffer( + wuffs_etc2__decoder* self) { + uint32_t v_bi = 0; + uint64_t v_alpha = 0; + uint32_t v_a0 = 0; + uint32_t v_multiplier = 0; + uint32_t v_which = 0; + uint32_t v_offset = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_shift = 0; + uint32_t v_delta = 0; + uint32_t v_o = 0; + + while (v_bi < self->private_impl.f_num_buffered_blocks) { + v_alpha = self->private_data.f_alphas[v_bi]; + v_a0 = ((uint32_t)((v_alpha >> 56u))); + v_multiplier = ((uint32_t)(((v_alpha >> 52u) & 15u))); + v_which = ((uint32_t)(((v_alpha >> 48u) & 15u))); + v_offset = (16u * v_bi); + v_y = 0u; + while (v_y < 4u) { + v_x = 0u; + while (v_x < 4u) { + v_shift = ((((v_x ^ 3u) * 4u) | (v_y ^ 3u)) * 3u); + v_delta = ((uint32_t)(v_multiplier * WUFFS_ETC2__ALPHA_MODIFIERS[v_which][(7u & (v_alpha >> v_shift))])); + v_o = (v_offset + (v_x * 4u) + (v_y * 1024u)); + self->private_data.f_buffer[(v_o + 3u)] = WUFFS_ETC2__CLAMP[(((uint32_t)(v_a0 + v_delta)) & 1023u)]; + v_x += 1u; + } + v_y += 1u; + } + v_bi += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.from_buffer_to_dst + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_etc2__decoder__from_buffer_to_dst( + wuffs_etc2__decoder* self, + wuffs_base__pixel_buffer* a_dst) { + wuffs_base__pixel_format v_dst_pixfmt = {0}; + uint32_t v_dst_bits_per_pixel = 0; + uint32_t v_dst_bytes_per_pixel = 0; + uint64_t v_dst_bytes_per_row = 0; + wuffs_base__table_u8 v_tab = {0}; + uint32_t v_bi = 0; + uint32_t v_rem_x = 0; + uint32_t v_dy = 0; + wuffs_base__slice_u8 v_dst = {0}; + wuffs_base__slice_u8 v_src = {0}; + uint32_t v_si = 0; + uint32_t v_sj = 0; + uint64_t v_i = 0; + uint32_t v_num_src_pixels = 0; + + v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); + v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); + if ((v_dst_bits_per_pixel & 7u) != 0u) { + return wuffs_base__make_status(wuffs_base__error__unsupported_option); + } + v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u); + v_dst_bytes_per_row = ((uint64_t)((self->private_impl.f_width * v_dst_bytes_per_pixel))); + v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); + while (v_bi < self->private_impl.f_num_buffered_blocks) { + if (self->private_impl.f_width <= self->private_impl.f_dst_x) { + self->private_impl.f_dst_x = 0u; + self->private_impl.f_dst_y += 4u; + if (self->private_impl.f_dst_y >= self->private_impl.f_height) { + break; + } + v_rem_x = self->private_impl.f_width; + } else { + v_rem_x = (self->private_impl.f_width - self->private_impl.f_dst_x); + } + v_dy = 0u; + while (v_dy < 4u) { + v_si = ((1024u * v_dy) + (16u * v_bi)); + v_sj = ((1024u * v_dy) + 1024u); + if (v_si < v_sj) { + v_src = wuffs_base__make_slice_u8_ij(self->private_data.f_buffer, v_si, v_sj); + } + if (((uint64_t)((4u * v_rem_x))) < ((uint64_t)(v_src.len))) { + v_src = wuffs_base__slice_u8__subslice_j(v_src, ((uint64_t)((4u * v_rem_x)))); + } + if (((uint32_t)(self->private_impl.f_dst_y + v_dy)) >= self->private_impl.f_height) { + break; + } + v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, ((uint32_t)(self->private_impl.f_dst_y + v_dy))); + if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); + } + v_i = (((uint64_t)(self->private_impl.f_dst_x)) * ((uint64_t)(v_dst_bytes_per_pixel))); + if (v_i < ((uint64_t)(v_dst.len))) { + wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, wuffs_base__slice_u8__subslice_i(v_dst, v_i), wuffs_base__pixel_buffer__palette(a_dst), v_src); + } + v_dy += 1u; + } + v_num_src_pixels = (((uint32_t)(((uint64_t)(v_src.len)))) / 4u); + self->private_impl.f_dst_x += v_num_src_pixels; + v_bi += ((v_num_src_pixels + 3u) / 4u); + } + return wuffs_base__make_status(NULL); +} + +// -------- func etc2.decoder.frame_dirty_rect + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 +wuffs_etc2__decoder__frame_dirty_rect( + const wuffs_etc2__decoder* self) { + if (!self) { + return wuffs_base__utility__empty_rect_ie_u32(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_rect_ie_u32(); + } + + return wuffs_base__utility__make_rect_ie_u32( + 0u, + 0u, + self->private_impl.f_width, + self->private_impl.f_height); +} + +// -------- func etc2.decoder.num_animation_loops + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_etc2__decoder__num_animation_loops( + const wuffs_etc2__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + +// -------- func etc2.decoder.num_decoded_frame_configs + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_etc2__decoder__num_decoded_frame_configs( + const wuffs_etc2__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + if (self->private_impl.f_call_sequence > 32u) { + return 1u; + } + return 0u; +} + +// -------- func etc2.decoder.num_decoded_frames + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_etc2__decoder__num_decoded_frames( + const wuffs_etc2__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + if (self->private_impl.f_call_sequence > 64u) { + return 1u; + } + return 0u; +} + +// -------- func etc2.decoder.restart_frame + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__restart_frame( + wuffs_etc2__decoder* self, + uint64_t a_index, + uint64_t a_io_position) { + 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 (self->private_impl.f_call_sequence < 32u) { + return wuffs_base__make_status(wuffs_base__error__bad_call_sequence); + } + if ((a_index != 0u) || (a_io_position != 16u)) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + self->private_impl.f_call_sequence = 40u; + return wuffs_base__make_status(NULL); +} + +// -------- func etc2.decoder.set_report_metadata + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_etc2__decoder__set_report_metadata( + wuffs_etc2__decoder* self, + uint32_t a_fourcc, + bool a_report) { + return wuffs_base__make_empty_struct(); +} + +// -------- func etc2.decoder.tell_me_more + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_etc2__decoder__tell_me_more( + wuffs_etc2__decoder* self, + wuffs_base__io_buffer* a_dst, + wuffs_base__more_information* a_minfo, + 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_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 != 4)) { + 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); + + status = wuffs_base__make_status(wuffs_base__error__no_more_information); + goto exit; + + goto ok; + ok: + goto exit; + exit: + if (wuffs_base__status__is_error(&status)) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + } + return status; +} + +// -------- func etc2.decoder.workbuf_len + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 +wuffs_etc2__decoder__workbuf_len( + const wuffs_etc2__decoder* self) { + if (!self) { + return wuffs_base__utility__empty_range_ii_u64(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_range_ii_u64(); + } + + return wuffs_base__utility__make_range_ii_u64(0u, 0u); +} + +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) + #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) // ---------------- Status Codes Implementations @@ -40674,7 +44312,7 @@ 88u, 77u, 80u, }; -#define WUFFS_GIF__QUIRKS_BASE 1041635328u +#define WUFFS_GIF__QUIRKS_BASE 983928832u #define WUFFS_GIF__QUIRKS_COUNT 7u @@ -40933,8 +44571,8 @@ uint32_t v_key = 0; - if (a_key >= 1041635328u) { - v_key = (a_key - 1041635328u); + if (a_key >= 983928832u) { + v_key = (a_key - 983928832u); if (v_key < 7u) { if (self->private_impl.f_quirks[v_key]) { return 1u; @@ -40962,8 +44600,8 @@ : wuffs_base__error__initialize_not_called); } - if ((self->private_impl.f_call_sequence == 0u) && (a_key >= 1041635328u)) { - a_key -= 1041635328u; + if ((self->private_impl.f_call_sequence == 0u) && (a_key >= 983928832u)) { + a_key -= 983928832u; if (a_key < 7u) { self->private_impl.f_quirks[a_key] = (a_value > 0u); return wuffs_base__make_status(NULL); @@ -44306,6 +47944,7 @@ const char wuffs_jpeg__error__missing_huffman_table[] = "#jpeg: missing Huffman table"; const char wuffs_jpeg__error__missing_quantization_table[] = "#jpeg: missing Quantization table"; const char wuffs_jpeg__error__rejected_progressive_jpeg[] = "#jpeg: rejected progressive JPEG"; +const char wuffs_jpeg__error__short_sos_bitstream[] = "#jpeg: short SOS bitstream"; const char wuffs_jpeg__error__truncated_input[] = "#jpeg: truncated input"; const char wuffs_jpeg__error__unsupported_arithmetic_coding[] = "#jpeg: unsupported arithmetic coding"; const char wuffs_jpeg__error__unsupported_color_model[] = "#jpeg: unsupported color model"; @@ -44544,7 +48183,7 @@ 248u, 249u, 250u, }; -#define WUFFS_JPEG__QUIRKS_BASE 1220532224u +#define WUFFS_JPEG__QUIRKS_BASE 1162824704u // ---------------- Private Initializer Prototypes @@ -46463,7 +50102,7 @@ if (self->private_impl.f_use_lower_quality) { return 18446744073709551615u; } - } else if (a_key == 1220532224u) { + } else if (a_key == 1162824704u) { if (self->private_impl.f_reject_progressive_jpegs) { return 1u; } @@ -46492,7 +50131,7 @@ if (a_key == 2u) { self->private_impl.f_use_lower_quality = (a_value >= 9223372036854775808u); return wuffs_base__make_status(NULL); - } else if (a_key == 1220532224u) { + } else if (a_key == 1162824704u) { self->private_impl.f_reject_progressive_jpegs = (a_value != 0u); return wuffs_base__make_status(NULL); } @@ -46694,6 +50333,9 @@ self->private_impl.f_payload_length = t_4; } if (self->private_impl.f_payload_length < 2u) { + if ((v_marker == 254u) || ((224u <= v_marker) && (v_marker < 240u))) { + continue; + } status = wuffs_base__make_status(wuffs_jpeg__error__bad_marker); goto exit; } @@ -46710,6 +50352,14 @@ } else if (self->private_impl.f_sof_marker != 0u) { status = wuffs_base__make_status(wuffs_jpeg__error__bad_sof_marker); goto exit; + } else if (v_marker == 192u) { + if (self->private_impl.f_seen_dht[2u] || + self->private_impl.f_seen_dht[3u] || + self->private_impl.f_seen_dht[6u] || + self->private_impl.f_seen_dht[7u]) { + status = wuffs_base__make_status(wuffs_jpeg__error__bad_sof_marker); + goto exit; + } } self->private_impl.f_sof_marker = v_marker; if (a_src) { @@ -46728,8 +50378,18 @@ status = wuffs_base__make_status(wuffs_jpeg__error__unsupported_lossless_coding); goto exit; } else if (v_marker == 196u) { - status = wuffs_base__make_status(wuffs_jpeg__error__bad_dht_marker); - goto exit; + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + status = wuffs_jpeg__decoder__decode_dht(self, a_src); + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + if (status.repr) { + goto suspend; + } + continue; } else if ((197u <= v_marker) && (v_marker <= 199u)) { status = wuffs_base__make_status(wuffs_jpeg__error__unsupported_hierarchical_coding); goto exit; @@ -46751,7 +50411,7 @@ 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_jpeg__decoder__decode_dqt(self, a_src); if (a_src) { iop_a_src = a_src->data.ptr + a_src->meta.ri; @@ -46764,7 +50424,7 @@ 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_jpeg__decoder__decode_dri(self, a_src); if (a_src) { iop_a_src = a_src->data.ptr + a_src->meta.ri; @@ -46781,7 +50441,7 @@ if (a_src) { a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); status = wuffs_jpeg__decoder__decode_appn(self, a_src, v_marker); if (a_src) { iop_a_src = a_src->data.ptr + a_src->meta.ri; @@ -46798,7 +50458,7 @@ } } self->private_data.s_do_decode_image_config.scratch = self->private_impl.f_payload_length; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(11); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(12); if (self->private_data.s_do_decode_image_config.scratch > ((uint64_t)(io2_a_src - iop_a_src))) { self->private_data.s_do_decode_image_config.scratch -= ((uint64_t)(io2_a_src - iop_a_src)); iop_a_src = io2_a_src; @@ -47912,11 +51572,11 @@ } self->private_impl.f_swizzle_immediately = false; if (self->private_impl.f_components_workbuf_offsets[8u] > ((uint64_t)(a_workbuf.len))) { - if (self->private_impl.f_sof_marker >= 194u) { + if ((self->private_impl.f_sof_marker >= 194u) || ! self->private_impl.f_use_lower_quality) { status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); goto exit; } - self->private_impl.f_swizzle_immediately = self->private_impl.f_use_lower_quality; + self->private_impl.f_swizzle_immediately = true; self->private_impl.f_swizzle_immediately_status = wuffs_base__make_status(NULL); } else if (self->private_impl.f_components_workbuf_offsets[4u] < self->private_impl.f_components_workbuf_offsets[8u]) { wuffs_private_impl__bulk_memset(a_workbuf.ptr + self->private_impl.f_components_workbuf_offsets[4u], (self->private_impl.f_components_workbuf_offsets[8u] - self->private_impl.f_components_workbuf_offsets[4u]), 0u); @@ -48146,10 +51806,6 @@ switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - if (self->private_impl.f_sof_marker == 0u) { - status = wuffs_base__make_status(wuffs_jpeg__error__bad_dht_marker); - goto exit; - } while (self->private_impl.f_payload_length > 0u) { if (self->private_impl.f_payload_length < 17u) { status = wuffs_base__make_status(wuffs_jpeg__error__bad_dht_marker); @@ -48473,7 +52129,7 @@ if (v_bitstream_length < ((uint32_t)(self->private_impl.f_bitstream_wi - self->private_impl.f_bitstream_ri))) { break; } else if (self->private_impl.f_bitstream_padding == 0u) { - status = wuffs_base__make_status(wuffs_jpeg__error__bad_sos_marker); + status = wuffs_base__make_status(wuffs_jpeg__error__short_sos_bitstream); goto exit; } else if ((a_src && a_src->meta.closed) && ! self->private_impl.f_bitstream_is_closed) { if (self->private_impl.f_bitstream_wi < 1024u) { @@ -49005,13 +52661,17 @@ continue; } else if (((uint64_t)(io2_a_src - iop_a_src)) <= 1u) { break; - } else if (((uint16_t)(wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8u)) > 0u) { - break; - } else { + } + v_c8 = iop_a_src[1u]; + if (v_c8 == 0u) { self->private_data.f_bitstream_buffer[v_wi] = 255u; v_wi += 1u; iop_a_src += 2u; + continue; + } else if (v_c8 < 255u) { + break; } + iop_a_src += 1u; } if (((uint64_t)(io2_a_src - iop_a_src)) > 1u) { if ((wuffs_base__peek_u8be__no_bounds_check(iop_a_src) >= 255u) && (((uint16_t)(wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8u)) > 0u)) { @@ -51489,7 +55149,7 @@ 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, }; -#define WUFFS_JSON__QUIRKS_BASE 1225364480u +#define WUFFS_JSON__QUIRKS_BASE 1167656960u #define WUFFS_JSON__QUIRKS_COUNT 21u @@ -51642,8 +55302,8 @@ uint32_t v_key = 0; - if (a_key >= 1225364480u) { - v_key = (a_key - 1225364480u); + if (a_key >= 1167656960u) { + v_key = (a_key - 1167656960u); if (v_key < 21u) { if (self->private_impl.f_quirks[v_key]) { return 1u; @@ -51671,8 +55331,8 @@ : wuffs_base__error__initialize_not_called); } - if (a_key >= 1225364480u) { - a_key -= 1225364480u; + if (a_key >= 1167656960u) { + a_key -= 1167656960u; if (a_key < 21u) { self->private_impl.f_quirks[a_key] = (a_value > 0u); return wuffs_base__make_status(NULL); @@ -53526,7 +57186,7 @@ 0u, 1u, 2u, 3u, 3u, 3u, 3u, 3u, }; -#define WUFFS_LZMA__QUIRKS_BASE 1348001792u +#define WUFFS_LZMA__QUIRKS_BASE 1290294272u // ---------------- Private Initializer Prototypes @@ -55693,11 +59353,11 @@ return 0; } - if (a_key == 1348001792u) { + if (a_key == 1290294272u) { if (self->private_impl.f_allow_non_zero_initial_byte) { return 1u; } - } else if (a_key == 1348001793u) { + } else if (a_key == 1290294273u) { return ((uint64_t)(self->private_impl.f_format_extension)); } return 0u; @@ -55724,9 +59384,9 @@ uint32_t v_v = 0; uint32_t v_n = 0; - if (a_key == 1348001792u) { + if (a_key == 1290294272u) { self->private_impl.f_allow_non_zero_initial_byte = (a_value > 0u); - } else if (a_key == 1348001793u) { + } else if (a_key == 1290294273u) { if (a_value == 0u) { self->private_impl.f_format_extension = 0u; return wuffs_base__make_status(NULL); @@ -57113,7 +60773,7 @@ uint8_t t_1 = *iop_a_src++; v_c8 = t_1; } - v_status = wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1348001793u, (1u | (((uint64_t)(v_c8)) << 8u))); + v_status = wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1290294273u, (1u | (((uint64_t)(v_c8)) << 8u))); if ( ! wuffs_base__status__is_ok(&v_status)) { if (v_status.repr == wuffs_base__error__bad_argument) { status = wuffs_base__make_status(wuffs_lzip__error__bad_header); @@ -57130,7 +60790,7 @@ } self->private_impl.f_ssize_have = 0u; self->private_impl.f_dsize_have = 0u; - wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1348001792u, 1u); + wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1290294272u, 1u); while (true) { v_dmark = ((uint64_t)(iop_a_dst - io0_a_dst)); v_smark = ((uint64_t)(iop_a_src - io0_a_src)); @@ -57317,7 +60977,7 @@ // ---------------- Private Consts -#define WUFFS_LZW__QUIRKS_BASE 1348378624u +#define WUFFS_LZW__QUIRKS_BASE 1290672128u // ---------------- Private Initializer Prototypes @@ -57438,7 +61098,7 @@ return 0; } - if (a_key == 1348378624u) { + if (a_key == 1290672128u) { return ((uint64_t)(self->private_impl.f_pending_literal_width_plus_one)); } return 0u; @@ -57462,7 +61122,7 @@ : wuffs_base__error__initialize_not_called); } - if (a_key == 1348378624u) { + if (a_key == 1290672128u) { if (a_value > 9u) { return wuffs_base__make_status(wuffs_base__error__bad_argument); } @@ -60098,7 +63758,7 @@ // ---------------- Private Consts -#define WUFFS_ZLIB__QUIRKS_BASE 2113790976u +#define WUFFS_ZLIB__QUIRKS_BASE 2056083456u #define WUFFS_ZLIB__QUIRKS_COUNT 1u @@ -60283,8 +63943,8 @@ if ((a_key == 1u) && self->private_impl.f_ignore_checksum) { return 1u; - } else if (a_key >= 2113790976u) { - v_key = (a_key - 2113790976u); + } else if (a_key >= 2056083456u) { + v_key = (a_key - 2056083456u); if (v_key < 1u) { if (self->private_impl.f_quirks[v_key]) { return 1u; @@ -60318,8 +63978,8 @@ } else if (a_key == 1u) { self->private_impl.f_ignore_checksum = (a_value > 0u); return wuffs_base__make_status(NULL); - } else if (a_key >= 2113790976u) { - a_key -= 2113790976u; + } else if (a_key >= 2056083456u) { + a_key -= 2056083456u; if (a_key < 1u) { self->private_impl.f_quirks[a_key] = (a_value > 0u); return wuffs_base__make_status(NULL); @@ -67737,7 +71397,7 @@ goto suspend; } } else if (self->private_impl.f_call_sequence == 40u) { - if (16u != wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)))) { + if (14u != 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; } @@ -69063,14 +72723,14 @@ #endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__SHA256) -#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) // ---------------- Status Codes Implementations -const char wuffs_tga__error__bad_header[] = "#tga: bad header"; -const char wuffs_tga__error__bad_run_length_encoding[] = "#tga: bad run length encoding"; -const char wuffs_tga__error__truncated_input[] = "#tga: truncated input"; -const char wuffs_tga__error__unsupported_tga_file[] = "#tga: unsupported TGA file"; +const char wuffs_targa__error__bad_header[] = "#targa: bad header"; +const char wuffs_targa__error__bad_run_length_encoding[] = "#targa: bad run length encoding"; +const char wuffs_targa__error__truncated_input[] = "#targa: truncated input"; +const char wuffs_targa__error__unsupported_targa_file[] = "#targa: unsupported TARGA file"; // ---------------- Private Consts @@ -69080,22 +72740,22 @@ WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status -wuffs_tga__decoder__do_decode_image_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__do_decode_image_config( + wuffs_targa__decoder* self, wuffs_base__image_config* a_dst, wuffs_base__io_buffer* a_src); WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status -wuffs_tga__decoder__do_decode_frame_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__do_decode_frame_config( + wuffs_targa__decoder* self, wuffs_base__frame_config* a_dst, wuffs_base__io_buffer* a_src); WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status -wuffs_tga__decoder__do_decode_frame( - wuffs_tga__decoder* self, +wuffs_targa__decoder__do_decode_frame( + wuffs_targa__decoder* self, wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__pixel_blend a_blend, @@ -69105,46 +72765,46 @@ // ---------------- VTables const wuffs_base__image_decoder__func_ptrs -wuffs_tga__decoder__func_ptrs_for__wuffs_base__image_decoder = { +wuffs_targa__decoder__func_ptrs_for__wuffs_base__image_decoder = { (wuffs_base__status(*)(void*, wuffs_base__pixel_buffer*, wuffs_base__io_buffer*, wuffs_base__pixel_blend, wuffs_base__slice_u8, - wuffs_base__decode_frame_options*))(&wuffs_tga__decoder__decode_frame), + wuffs_base__decode_frame_options*))(&wuffs_targa__decoder__decode_frame), (wuffs_base__status(*)(void*, wuffs_base__frame_config*, - wuffs_base__io_buffer*))(&wuffs_tga__decoder__decode_frame_config), + wuffs_base__io_buffer*))(&wuffs_targa__decoder__decode_frame_config), (wuffs_base__status(*)(void*, wuffs_base__image_config*, - wuffs_base__io_buffer*))(&wuffs_tga__decoder__decode_image_config), - (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_tga__decoder__frame_dirty_rect), + wuffs_base__io_buffer*))(&wuffs_targa__decoder__decode_image_config), + (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_targa__decoder__frame_dirty_rect), (uint64_t(*)(const void*, - uint32_t))(&wuffs_tga__decoder__get_quirk), - (uint32_t(*)(const void*))(&wuffs_tga__decoder__num_animation_loops), - (uint64_t(*)(const void*))(&wuffs_tga__decoder__num_decoded_frame_configs), - (uint64_t(*)(const void*))(&wuffs_tga__decoder__num_decoded_frames), + uint32_t))(&wuffs_targa__decoder__get_quirk), + (uint32_t(*)(const void*))(&wuffs_targa__decoder__num_animation_loops), + (uint64_t(*)(const void*))(&wuffs_targa__decoder__num_decoded_frame_configs), + (uint64_t(*)(const void*))(&wuffs_targa__decoder__num_decoded_frames), (wuffs_base__status(*)(void*, uint64_t, - uint64_t))(&wuffs_tga__decoder__restart_frame), + uint64_t))(&wuffs_targa__decoder__restart_frame), (wuffs_base__status(*)(void*, uint32_t, - uint64_t))(&wuffs_tga__decoder__set_quirk), + uint64_t))(&wuffs_targa__decoder__set_quirk), (wuffs_base__empty_struct(*)(void*, uint32_t, - bool))(&wuffs_tga__decoder__set_report_metadata), + bool))(&wuffs_targa__decoder__set_report_metadata), (wuffs_base__status(*)(void*, wuffs_base__io_buffer*, wuffs_base__more_information*, - wuffs_base__io_buffer*))(&wuffs_tga__decoder__tell_me_more), - (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_tga__decoder__workbuf_len), + wuffs_base__io_buffer*))(&wuffs_targa__decoder__tell_me_more), + (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_targa__decoder__workbuf_len), }; // ---------------- Initializer Implementations wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT -wuffs_tga__decoder__initialize( - wuffs_tga__decoder* self, +wuffs_targa__decoder__initialize( + wuffs_targa__decoder* self, size_t sizeof_star_self, uint64_t wuffs_version, uint32_t options){ @@ -69185,19 +72845,19 @@ self->private_impl.vtable_for__wuffs_base__image_decoder.vtable_name = wuffs_base__image_decoder__vtable_name; self->private_impl.vtable_for__wuffs_base__image_decoder.function_pointers = - (const void*)(&wuffs_tga__decoder__func_ptrs_for__wuffs_base__image_decoder); + (const void*)(&wuffs_targa__decoder__func_ptrs_for__wuffs_base__image_decoder); return wuffs_base__make_status(NULL); } -wuffs_tga__decoder* -wuffs_tga__decoder__alloc(void) { - wuffs_tga__decoder* x = - (wuffs_tga__decoder*)(calloc(1, sizeof(wuffs_tga__decoder))); +wuffs_targa__decoder* +wuffs_targa__decoder__alloc(void) { + wuffs_targa__decoder* x = + (wuffs_targa__decoder*)(calloc(1, sizeof(wuffs_targa__decoder))); if (!x) { return NULL; } - if (wuffs_tga__decoder__initialize( - x, sizeof(wuffs_tga__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) { + if (wuffs_targa__decoder__initialize( + x, sizeof(wuffs_targa__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) { free(x); return NULL; } @@ -69205,18 +72865,18 @@ } size_t -sizeof__wuffs_tga__decoder(void) { - return sizeof(wuffs_tga__decoder); +sizeof__wuffs_targa__decoder(void) { + return sizeof(wuffs_targa__decoder); } // ---------------- Function Implementations -// -------- func tga.decoder.get_quirk +// -------- func targa.decoder.get_quirk WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_tga__decoder__get_quirk( - const wuffs_tga__decoder* self, +wuffs_targa__decoder__get_quirk( + const wuffs_targa__decoder* self, uint32_t a_key) { if (!self) { return 0; @@ -69229,12 +72889,12 @@ return 0u; } -// -------- func tga.decoder.set_quirk +// -------- func targa.decoder.set_quirk WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__set_quirk( - wuffs_tga__decoder* self, +wuffs_targa__decoder__set_quirk( + wuffs_targa__decoder* self, uint32_t a_key, uint64_t a_value) { if (!self) { @@ -69250,12 +72910,12 @@ return wuffs_base__make_status(wuffs_base__error__unsupported_option); } -// -------- func tga.decoder.decode_image_config +// -------- func targa.decoder.decode_image_config WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__decode_image_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__decode_image_config( + wuffs_targa__decoder* self, wuffs_base__image_config* a_dst, wuffs_base__io_buffer* a_src) { if (!self) { @@ -69287,11 +72947,11 @@ while (true) { { - wuffs_base__status t_0 = wuffs_tga__decoder__do_decode_image_config(self, a_dst, a_src); + wuffs_base__status t_0 = wuffs_targa__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_tga__error__truncated_input); + status = wuffs_base__make_status(wuffs_targa__error__truncated_input); goto exit; } status = v_status; @@ -69316,12 +72976,12 @@ return status; } -// -------- func tga.decoder.do_decode_image_config +// -------- func targa.decoder.do_decode_image_config WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status -wuffs_tga__decoder__do_decode_image_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__do_decode_image_config( + wuffs_targa__decoder* self, wuffs_base__image_config* a_dst, wuffs_base__io_buffer* a_src) { wuffs_base__status status = wuffs_base__make_status(NULL); @@ -69371,7 +73031,7 @@ self->private_impl.f_header_color_map_type = t_1; } if (self->private_impl.f_header_color_map_type > 1u) { - status = wuffs_base__make_status(wuffs_tga__error__bad_header); + status = wuffs_base__make_status(wuffs_targa__error__bad_header); goto exit; } { @@ -69390,7 +73050,7 @@ (self->private_impl.f_header_image_type == 10u) || (self->private_impl.f_header_image_type == 11u)) { } else { - status = wuffs_base__make_status(wuffs_tga__error__bad_header); + status = wuffs_base__make_status(wuffs_targa__error__bad_header); goto exit; } { @@ -69462,18 +73122,18 @@ } if (self->private_impl.f_header_color_map_type != 0u) { if ((self->private_impl.f_header_color_map_first_entry_index != 0u) || (self->private_impl.f_header_color_map_length > 256u)) { - status = wuffs_base__make_status(wuffs_tga__error__unsupported_tga_file); + status = wuffs_base__make_status(wuffs_targa__error__unsupported_targa_file); goto exit; } else if ((self->private_impl.f_header_color_map_entry_size != 15u) && (self->private_impl.f_header_color_map_entry_size != 16u) && (self->private_impl.f_header_color_map_entry_size != 24u) && (self->private_impl.f_header_color_map_entry_size != 32u)) { - status = wuffs_base__make_status(wuffs_tga__error__bad_header); + status = wuffs_base__make_status(wuffs_targa__error__bad_header); goto exit; } } else { if ((self->private_impl.f_header_color_map_first_entry_index != 0u) || (self->private_impl.f_header_color_map_length != 0u) || (self->private_impl.f_header_color_map_entry_size != 0u)) { - status = wuffs_base__make_status(wuffs_tga__error__bad_header); + status = wuffs_base__make_status(wuffs_targa__error__bad_header); goto exit; } } @@ -69559,7 +73219,7 @@ (self->private_impl.f_header_pixel_depth != 16u) && (self->private_impl.f_header_pixel_depth != 24u) && (self->private_impl.f_header_pixel_depth != 32u)) { - status = wuffs_base__make_status(wuffs_tga__error__bad_header); + status = wuffs_base__make_status(wuffs_targa__error__bad_header); goto exit; } if (((uint8_t)(self->private_impl.f_header_image_type | 8u)) == 9u) { @@ -69582,7 +73242,7 @@ self->private_impl.f_src_bytes_per_pixel = 4u; self->private_impl.f_src_pixfmt = 2164295816u; } else { - status = wuffs_base__make_status(wuffs_tga__error__unsupported_tga_file); + status = wuffs_base__make_status(wuffs_targa__error__unsupported_targa_file); goto exit; } } else { @@ -69592,7 +73252,7 @@ self->private_impl.f_src_pixfmt = 536870920u; self->private_impl.f_opaque = true; } else { - status = wuffs_base__make_status(wuffs_tga__error__unsupported_tga_file); + status = wuffs_base__make_status(wuffs_targa__error__unsupported_targa_file); goto exit; } } @@ -69606,7 +73266,7 @@ self->private_impl.f_header_image_descriptor = t_9; } if (((uint8_t)(self->private_impl.f_header_image_descriptor & 16u)) != 0u) { - status = wuffs_base__make_status(wuffs_tga__error__unsupported_tga_file); + status = wuffs_base__make_status(wuffs_targa__error__unsupported_targa_file); goto exit; } self->private_data.s_do_decode_image_config.scratch = ((uint32_t)(self->private_impl.f_header_id_length)); @@ -69769,12 +73429,12 @@ return status; } -// -------- func tga.decoder.decode_frame_config +// -------- func targa.decoder.decode_frame_config WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__decode_frame_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__decode_frame_config( + wuffs_targa__decoder* self, wuffs_base__frame_config* a_dst, wuffs_base__io_buffer* a_src) { if (!self) { @@ -69806,11 +73466,11 @@ while (true) { { - wuffs_base__status t_0 = wuffs_tga__decoder__do_decode_frame_config(self, a_dst, a_src); + wuffs_base__status t_0 = wuffs_targa__decoder__do_decode_frame_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_tga__error__truncated_input); + status = wuffs_base__make_status(wuffs_targa__error__truncated_input); goto exit; } status = v_status; @@ -69835,12 +73495,12 @@ return status; } -// -------- func tga.decoder.do_decode_frame_config +// -------- func targa.decoder.do_decode_frame_config WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status -wuffs_tga__decoder__do_decode_frame_config( - wuffs_tga__decoder* self, +wuffs_targa__decoder__do_decode_frame_config( + wuffs_targa__decoder* self, wuffs_base__frame_config* a_dst, wuffs_base__io_buffer* a_src) { wuffs_base__status status = wuffs_base__make_status(NULL); @@ -69866,7 +73526,7 @@ a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - status = wuffs_tga__decoder__do_decode_image_config(self, NULL, a_src); + status = wuffs_targa__decoder__do_decode_image_config(self, NULL, a_src); if (a_src) { iop_a_src = a_src->data.ptr + a_src->meta.ri; } @@ -69922,12 +73582,12 @@ return status; } -// -------- func tga.decoder.decode_frame +// -------- func targa.decoder.decode_frame WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__decode_frame( - wuffs_tga__decoder* self, +wuffs_targa__decoder__decode_frame( + wuffs_targa__decoder* self, wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__pixel_blend a_blend, @@ -69962,7 +73622,7 @@ while (true) { { - wuffs_base__status t_0 = wuffs_tga__decoder__do_decode_frame(self, + wuffs_base__status t_0 = wuffs_targa__decoder__do_decode_frame(self, a_dst, a_src, a_blend, @@ -69971,7 +73631,7 @@ 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_tga__error__truncated_input); + status = wuffs_base__make_status(wuffs_targa__error__truncated_input); goto exit; } status = v_status; @@ -69996,12 +73656,12 @@ return status; } -// -------- func tga.decoder.do_decode_frame +// -------- func targa.decoder.do_decode_frame WUFFS_BASE__GENERATED_C_CODE static wuffs_base__status -wuffs_tga__decoder__do_decode_frame( - wuffs_tga__decoder* self, +wuffs_targa__decoder__do_decode_frame( + wuffs_targa__decoder* self, wuffs_base__pixel_buffer* a_dst, wuffs_base__io_buffer* a_src, wuffs_base__pixel_blend a_blend, @@ -70061,7 +73721,7 @@ a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); } WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); - status = wuffs_tga__decoder__do_decode_frame_config(self, NULL, a_src); + status = wuffs_targa__decoder__do_decode_frame_config(self, NULL, a_src); if (a_src) { iop_a_src = a_src->data.ptr + a_src->meta.ri; } @@ -70163,7 +73823,7 @@ v_lit_length = (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) + 1u); iop_a_src += 1u; if ((v_lit_length + v_dst_x) > self->private_impl.f_width) { - status = wuffs_base__make_status(wuffs_tga__error__bad_run_length_encoding); + status = wuffs_base__make_status(wuffs_targa__error__bad_run_length_encoding); goto exit; } } else { @@ -70209,7 +73869,7 @@ iop_a_src += 1u; } if ((v_run_length + v_dst_x) > self->private_impl.f_width) { - status = wuffs_base__make_status(wuffs_tga__error__bad_run_length_encoding); + status = wuffs_base__make_status(wuffs_targa__error__bad_run_length_encoding); goto exit; } } @@ -70253,7 +73913,7 @@ v_lit_length = (((uint32_t)(wuffs_base__peek_u8be__no_bounds_check(iop_a_src))) + 1u); iop_a_src += 1u; if ((v_lit_length + v_dst_x) > self->private_impl.f_width) { - status = wuffs_base__make_status(wuffs_tga__error__bad_run_length_encoding); + status = wuffs_base__make_status(wuffs_targa__error__bad_run_length_encoding); goto exit; } } else { @@ -70274,7 +73934,7 @@ self->private_data.f_scratch[2u] = ((uint8_t)(((v_c5 << 3u) | (v_c5 >> 2u)))); self->private_data.f_scratch[3u] = 255u; if ((v_run_length + v_dst_x) > self->private_impl.f_width) { - status = wuffs_base__make_status(wuffs_tga__error__bad_run_length_encoding); + status = wuffs_base__make_status(wuffs_targa__error__bad_run_length_encoding); goto exit; } } @@ -70321,12 +73981,12 @@ return status; } -// -------- func tga.decoder.frame_dirty_rect +// -------- func targa.decoder.frame_dirty_rect WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 -wuffs_tga__decoder__frame_dirty_rect( - const wuffs_tga__decoder* self) { +wuffs_targa__decoder__frame_dirty_rect( + const wuffs_targa__decoder* self) { if (!self) { return wuffs_base__utility__empty_rect_ie_u32(); } @@ -70342,12 +74002,12 @@ self->private_impl.f_height); } -// -------- func tga.decoder.num_animation_loops +// -------- func targa.decoder.num_animation_loops WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint32_t -wuffs_tga__decoder__num_animation_loops( - const wuffs_tga__decoder* self) { +wuffs_targa__decoder__num_animation_loops( + const wuffs_targa__decoder* self) { if (!self) { return 0; } @@ -70359,12 +74019,12 @@ return 0u; } -// -------- func tga.decoder.num_decoded_frame_configs +// -------- func targa.decoder.num_decoded_frame_configs WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_tga__decoder__num_decoded_frame_configs( - const wuffs_tga__decoder* self) { +wuffs_targa__decoder__num_decoded_frame_configs( + const wuffs_targa__decoder* self) { if (!self) { return 0; } @@ -70379,12 +74039,12 @@ return 0u; } -// -------- func tga.decoder.num_decoded_frames +// -------- func targa.decoder.num_decoded_frames WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC uint64_t -wuffs_tga__decoder__num_decoded_frames( - const wuffs_tga__decoder* self) { +wuffs_targa__decoder__num_decoded_frames( + const wuffs_targa__decoder* self) { if (!self) { return 0; } @@ -70399,12 +74059,12 @@ return 0u; } -// -------- func tga.decoder.restart_frame +// -------- func targa.decoder.restart_frame WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__restart_frame( - wuffs_tga__decoder* self, +wuffs_targa__decoder__restart_frame( + wuffs_targa__decoder* self, uint64_t a_index, uint64_t a_io_position) { if (!self) { @@ -70428,23 +74088,23 @@ return wuffs_base__make_status(NULL); } -// -------- func tga.decoder.set_report_metadata +// -------- func targa.decoder.set_report_metadata WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct -wuffs_tga__decoder__set_report_metadata( - wuffs_tga__decoder* self, +wuffs_targa__decoder__set_report_metadata( + wuffs_targa__decoder* self, uint32_t a_fourcc, bool a_report) { return wuffs_base__make_empty_struct(); } -// -------- func tga.decoder.tell_me_more +// -------- func targa.decoder.tell_me_more WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__status -wuffs_tga__decoder__tell_me_more( - wuffs_tga__decoder* self, +wuffs_targa__decoder__tell_me_more( + wuffs_targa__decoder* self, wuffs_base__io_buffer* a_dst, wuffs_base__more_information* a_minfo, wuffs_base__io_buffer* a_src) { @@ -70482,12 +74142,12 @@ return status; } -// -------- func tga.decoder.workbuf_len +// -------- func targa.decoder.workbuf_len WUFFS_BASE__GENERATED_C_CODE WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 -wuffs_tga__decoder__workbuf_len( - const wuffs_tga__decoder* self) { +wuffs_targa__decoder__workbuf_len( + const wuffs_targa__decoder* self) { if (!self) { return wuffs_base__utility__empty_range_ii_u64(); } @@ -70499,7 +74159,1719 @@ return wuffs_base__utility__make_range_ii_u64(0u, 0u); } -#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) + +// ---------------- Status Codes Implementations + +const char wuffs_thumbhash__error__bad_header[] = "#thumbhash: bad header"; +const char wuffs_thumbhash__error__truncated_input[] = "#thumbhash: truncated input"; + +// ---------------- Private Consts + +#define WUFFS_THUMBHASH__QUIRKS_BASE 1712283648u + +static const uint8_t +WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[8] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0u, 14u, 18u, 19u, 23u, 26u, 27u, 32u, +}; + +static const uint8_t +WUFFS_THUMBHASH__CUMULATIVE_DIMENSIONS[8] WUFFS_BASE__POTENTIALLY_UNUSED = { + 0u, 0u, 14u, 32u, 51u, 74u, 100u, 127u, +}; + +static const uint8_t +WUFFS_THUMBHASH__DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT[2][8] WUFFS_BASE__POTENTIALLY_UNUSED = { + { + 23u, 23u, 23u, 23u, 39u, 71u, 103u, 119u, + }, { + 55u, 55u, 55u, 55u, 87u, 119u, 118u, 116u, + }, +}; + +static const uint16_t +WUFFS_THUMBHASH__FROM_4_BITS_TO_PLUS_MINUS_1_00[16] WUFFS_BASE__POTENTIALLY_UNUSED = { + 49152u, 51337u, 53521u, 55706u, 57890u, 60075u, 62259u, 64444u, + 1092u, 3277u, 5461u, 7646u, 9830u, 12015u, 14199u, 16384u, +}; + +static const uint16_t +WUFFS_THUMBHASH__FROM_4_BITS_TO_PLUS_MINUS_1_25[16] WUFFS_BASE__POTENTIALLY_UNUSED = { + 45056u, 47787u, 50517u, 53248u, 55979u, 58709u, 61440u, 64171u, + 1365u, 4096u, 6827u, 9557u, 12288u, 15019u, 17749u, 20480u, +}; + +static const uint16_t +WUFFS_THUMBHASH__COSINES[159][6] WUFFS_BASE__POTENTIALLY_UNUSED = { + { + 16281u, 15973u, 15465u, 14761u, 13873u, 12810u, + }, { + 15465u, 12810u, 8717u, 3646u, 63702u, 58427u, + }, { + 13873u, 7109u, 63702u, 55321u, 50071u, 49563u, + }, { + 11585u, 0u, 53951u, 49152u, 53951u, 0u, + }, { + 8717u, 58427u, 49255u, 55321u, 5411u, 15973u, + }, { + 5411u, 52726u, 51663u, 3646u, 16281u, 7109u, + }, { + 1834u, 49563u, 60125u, 14761u, 8717u, 52726u, + }, { + 63702u, 49563u, 5411u, 14761u, 56819u, 52726u, + }, + { + 60125u, 52726u, 13873u, 3646u, 49255u, 7109u, + }, { + 56819u, 58427u, 16281u, 55321u, 60125u, 15973u, + }, { + 53951u, 0u, 11585u, 49152u, 11585u, 0u, + }, { + 51663u, 7109u, 1834u, 55321u, 15465u, 49563u, + }, { + 50071u, 12810u, 56819u, 3646u, 1834u, 58427u, + }, { + 49255u, 15973u, 50071u, 14761u, 51663u, 12810u, + }, { + 16322u, 16135u, 15826u, 15396u, 14849u, 14189u, + }, { + 15826u, 14189u, 11585u, 8192u, 4240u, 0u, + }, + { + 14849u, 10531u, 4240u, 62691u, 56139u, 51347u, + }, { + 13421u, 5604u, 61296u, 52985u, 49214u, 51347u, + }, { + 11585u, 0u, 53951u, 49152u, 53951u, 0u, + }, { + 9397u, 59932u, 49710u, 52985u, 1428u, 14189u, + }, { + 6924u, 55005u, 49710u, 62691u, 13421u, 14189u, + }, { + 4240u, 51347u, 53951u, 8192u, 15826u, 0u, + }, { + 1428u, 49401u, 61296u, 15396u, 6924u, 51347u, + }, { + 64108u, 49401u, 4240u, 15396u, 58612u, 51347u, + }, + { + 61296u, 51347u, 11585u, 8192u, 49710u, 0u, + }, { + 58612u, 55005u, 15826u, 62691u, 52115u, 14189u, + }, { + 56139u, 59932u, 15826u, 52985u, 64108u, 14189u, + }, { + 53951u, 0u, 11585u, 49152u, 11585u, 0u, + }, { + 52115u, 5604u, 4240u, 52985u, 16322u, 51347u, + }, { + 50687u, 10531u, 61296u, 62691u, 9397u, 51347u, + }, { + 49710u, 14189u, 53951u, 8192u, 61296u, 0u, + }, { + 49214u, 16135u, 49710u, 15396u, 50687u, 14189u, + }, + { + 16328u, 16161u, 15883u, 15496u, 15004u, 14409u, + }, { + 15883u, 14409u, 12054u, 8961u, 5320u, 1353u, + }, { + 15004u, 11097u, 5320u, 64183u, 57738u, 52607u, + }, { + 13716u, 6581u, 62839u, 54439u, 49653u, 50040u, + }, { + 12054u, 1353u, 55473u, 49375u, 51820u, 61514u, + }, { + 10063u, 61514u, 50532u, 51127u, 62839u, 11097u, + }, { + 7798u, 56575u, 49208u, 58955u, 10063u, 16161u, + }, { + 5320u, 52607u, 51820u, 4022u, 16328u, 6581u, + }, + { + 2697u, 50040u, 57738u, 12929u, 12054u, 56575u, + }, { + 0u, 49152u, 0u, 16384u, 0u, 49152u, + }, { + 62839u, 50040u, 7798u, 12929u, 53482u, 56575u, + }, { + 60216u, 52607u, 13716u, 4022u, 49208u, 6581u, + }, { + 57738u, 56575u, 16328u, 58955u, 55473u, 16161u, + }, { + 55473u, 61514u, 15004u, 51127u, 2697u, 11097u, + }, { + 53482u, 1353u, 10063u, 49375u, 13716u, 61514u, + }, { + 51820u, 6581u, 2697u, 54439u, 15883u, 50040u, + }, + { + 50532u, 11097u, 60216u, 64183u, 7798u, 52607u, + }, { + 49653u, 14409u, 53482u, 8961u, 60216u, 1353u, + }, { + 49208u, 16161u, 49653u, 15496u, 50532u, 14409u, + }, { + 16346u, 16231u, 16041u, 15776u, 15438u, 15028u, + }, { + 16041u, 15028u, 13385u, 11183u, 8513u, 5487u, + }, { + 15438u, 12709u, 8513u, 3333u, 63305u, 57998u, + }, { + 14547u, 9448u, 2231u, 60049u, 53562u, 49760u, + }, { + 13385u, 5487u, 61116u, 52827u, 49190u, 51537u, + }, + { + 11974u, 1118u, 55196u, 49305u, 52151u, 62203u, + }, { + 10340u, 62203u, 50989u, 50508u, 61116u, 9448u, + }, { + 8513u, 57998u, 49190u, 56088u, 6527u, 16231u, + }, { + 6527u, 54353u, 50098u, 64418u, 14547u, 12709u, + }, { + 4420u, 51537u, 53562u, 7538u, 16041u, 1118u, + }, { + 2231u, 49760u, 59009u, 13999u, 10340u, 54353u, + }, { + 0u, 49152u, 0u, 16384u, 0u, 49152u, + }, { + 63305u, 49760u, 6527u, 13999u, 55196u, 54353u, + }, + { + 61116u, 51537u, 11974u, 7538u, 49495u, 1118u, + }, { + 59009u, 54353u, 15438u, 64418u, 50989u, 12709u, + }, { + 57023u, 57998u, 16346u, 56088u, 59009u, 16231u, + }, { + 55196u, 62203u, 14547u, 50508u, 4420u, 9448u, + }, { + 53562u, 1118u, 10340u, 49305u, 13385u, 62203u, + }, { + 52151u, 5487u, 4420u, 52827u, 16346u, 51537u, + }, { + 50989u, 9448u, 63305u, 60049u, 11974u, 49760u, + }, { + 50098u, 12709u, 57023u, 3333u, 2231u, 57998u, + }, + { + 49495u, 15028u, 52151u, 11183u, 57023u, 5487u, + }, { + 49190u, 16231u, 49495u, 15776u, 50098u, 15028u, + }, { + 16354u, 16265u, 16116u, 15908u, 15642u, 15319u, + }, { + 16116u, 15319u, 14021u, 12264u, 10104u, 7614u, + }, { + 15642u, 13484u, 10104u, 5810u, 989u, 61615u, + }, { + 14941u, 10865u, 4874u, 63561u, 57060u, 52052u, + }, { + 14021u, 7614u, 64547u, 56229u, 50595u, 49271u, + }, { + 12897u, 3921u, 58812u, 51029u, 49420u, 54671u, + }, + { + 11585u, 0u, 53951u, 49152u, 53951u, 0u, + }, { + 10104u, 61615u, 50595u, 51029u, 62583u, 10865u, + }, { + 8476u, 57922u, 49182u, 56229u, 6724u, 16265u, + }, { + 6724u, 54671u, 49894u, 63561u, 14021u, 13484u, + }, { + 4874u, 52052u, 52639u, 5810u, 16354u, 3921u, + }, { + 2953u, 50217u, 57060u, 12264u, 12897u, 57922u, + }, { + 989u, 49271u, 62583u, 15908u, 4874u, 50217u, + }, { + 64547u, 49271u, 2953u, 15908u, 60662u, 50217u, + }, + { + 62583u, 50217u, 8476u, 12264u, 52639u, 57922u, + }, { + 60662u, 52052u, 12897u, 5810u, 49182u, 3921u, + }, { + 58812u, 54671u, 15642u, 63561u, 51515u, 13484u, + }, { + 57060u, 57922u, 16354u, 56229u, 58812u, 16265u, + }, { + 55432u, 61615u, 14941u, 51029u, 2953u, 10865u, + }, { + 53951u, 0u, 11585u, 49152u, 11585u, 0u, + }, { + 52639u, 3921u, 6724u, 51029u, 16116u, 54671u, + }, { + 51515u, 7614u, 989u, 56229u, 14941u, 49271u, + }, + { + 50595u, 10865u, 60662u, 63561u, 8476u, 52052u, + }, { + 49894u, 13484u, 55432u, 5810u, 64547u, 61615u, + }, { + 49420u, 15319u, 51515u, 12264u, 55432u, 7614u, + }, { + 49182u, 16265u, 49420u, 15908u, 49894u, 15319u, + }, { + 16356u, 16273u, 16135u, 15942u, 15696u, 15396u, + }, { + 16135u, 15396u, 14189u, 12551u, 10531u, 8192u, + }, { + 15696u, 13689u, 10531u, 6489u, 1902u, 62691u, + }, { + 15044u, 11243u, 5604u, 64583u, 58183u, 52985u, + }, + { + 14189u, 8192u, 0u, 57344u, 51347u, 49152u, + }, { + 13142u, 4699u, 59932u, 51847u, 49180u, 52985u, + }, { + 11917u, 953u, 55005u, 49263u, 52394u, 62691u, + }, { + 10531u, 62691u, 51347u, 50140u, 59932u, 8192u, + }, { + 9003u, 59047u, 49401u, 54293u, 3778u, 15396u, + }, { + 7353u, 55752u, 49401u, 60837u, 11917u, 15396u, + }, { + 5604u, 52985u, 51347u, 2845u, 16135u, 8192u, + }, { + 3778u, 50895u, 55005u, 9784u, 15044u, 62691u, + }, + { + 1902u, 49594u, 59932u, 14641u, 9003u, 52985u, + }, { + 0u, 49152u, 0u, 16384u, 0u, 49152u, + }, { + 63634u, 49594u, 5604u, 14641u, 56533u, 52985u, + }, { + 61758u, 50895u, 10531u, 9784u, 50492u, 62691u, + }, { + 59932u, 52985u, 14189u, 2845u, 49401u, 8192u, + }, { + 58183u, 55752u, 16135u, 60837u, 53619u, 15396u, + }, { + 56533u, 59047u, 16135u, 54293u, 61758u, 15396u, + }, { + 55005u, 62691u, 14189u, 50140u, 5604u, 8192u, + }, + { + 53619u, 953u, 10531u, 49263u, 13142u, 62691u, + }, { + 52394u, 4699u, 5604u, 51847u, 16356u, 52985u, + }, { + 51347u, 8192u, 0u, 57344u, 14189u, 49152u, + }, { + 50492u, 11243u, 59932u, 64583u, 7353u, 52985u, + }, { + 49840u, 13689u, 55005u, 6489u, 63634u, 62691u, + }, { + 49401u, 15396u, 51347u, 12551u, 55005u, 8192u, + }, { + 49180u, 16273u, 49401u, 15942u, 49840u, 15396u, + }, { + 16364u, 16305u, 16207u, 16069u, 15893u, 15679u, + }, + { + 16207u, 15679u, 14811u, 13623u, 12140u, 10394u, + }, { + 15893u, 14449u, 12140u, 9102u, 5520u, 1606u, + }, { + 15426u, 12665u, 8423u, 3196u, 63132u, 57813u, + }, { + 14811u, 10394u, 3981u, 62340u, 55776u, 51087u, + }, { + 14053u, 7723u, 64732u, 56434u, 50725u, 49231u, + }, { + 13160u, 4756u, 60016u, 51913u, 49172u, 52871u, + }, { + 12140u, 1606u, 55776u, 49467u, 51483u, 60780u, + }, { + 11003u, 63930u, 52376u, 49467u, 57113u, 4756u, + }, + { + 9760u, 60780u, 50110u, 51913u, 64732u, 12665u, + }, { + 8423u, 57813u, 49172u, 56434u, 7005u, 16305u, + }, { + 7005u, 55142u, 49643u, 62340u, 13160u, 14449u, + }, { + 5520u, 52871u, 51483u, 3196u, 16207u, 7723u, + }, { + 3981u, 51087u, 54533u, 9102u, 15426u, 63930u, + }, { + 2404u, 49857u, 58531u, 13623u, 11003u, 55142u, + }, { + 804u, 49231u, 63132u, 16069u, 3981u, 49857u, + }, { + 64732u, 49231u, 2404u, 16069u, 61555u, 49857u, + }, + { + 63132u, 49857u, 7005u, 13623u, 54533u, 55142u, + }, { + 61555u, 51087u, 11003u, 9102u, 50110u, 63930u, + }, { + 60016u, 52871u, 14053u, 3196u, 49329u, 7723u, + }, { + 58531u, 55142u, 15893u, 62340u, 52376u, 14449u, + }, { + 57113u, 57813u, 16364u, 56434u, 58531u, 16305u, + }, { + 55776u, 60780u, 15426u, 51913u, 804u, 12665u, + }, { + 54533u, 63930u, 13160u, 49467u, 8423u, 4756u, + }, { + 53396u, 1606u, 9760u, 49467u, 14053u, 60780u, + }, + { + 52376u, 4756u, 5520u, 51913u, 16364u, 52871u, + }, { + 51483u, 7723u, 804u, 56434u, 14811u, 49231u, + }, { + 50725u, 10394u, 61555u, 62340u, 9760u, 51087u, + }, { + 50110u, 12665u, 57113u, 3196u, 2404u, 57813u, + }, { + 49643u, 14449u, 53396u, 9102u, 60016u, 1606u, + }, { + 49329u, 15679u, 50725u, 13623u, 53396u, 10394u, + }, { + 49172u, 16305u, 49329u, 16069u, 49643u, 15679u, + }, +}; + +// ---------------- Private Initializer Prototypes + +// ---------------- Private Function Prototypes + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__do_decode_image_config( + wuffs_thumbhash__decoder* self, + wuffs_base__image_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__do_decode_frame_config( + wuffs_thumbhash__decoder* self, + wuffs_base__frame_config* a_dst, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__do_decode_frame( + wuffs_thumbhash__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__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__from_src_to_coeffs( + wuffs_thumbhash__decoder* self, + wuffs_base__io_buffer* a_src); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_thumbhash__decoder__from_coeffs_to_pixels( + wuffs_thumbhash__decoder* self); + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__from_pixels_to_dst( + wuffs_thumbhash__decoder* self, + wuffs_base__pixel_buffer* a_dst); + +// ---------------- VTables + +const wuffs_base__image_decoder__func_ptrs +wuffs_thumbhash__decoder__func_ptrs_for__wuffs_base__image_decoder = { + (wuffs_base__status(*)(void*, + wuffs_base__pixel_buffer*, + wuffs_base__io_buffer*, + wuffs_base__pixel_blend, + wuffs_base__slice_u8, + wuffs_base__decode_frame_options*))(&wuffs_thumbhash__decoder__decode_frame), + (wuffs_base__status(*)(void*, + wuffs_base__frame_config*, + wuffs_base__io_buffer*))(&wuffs_thumbhash__decoder__decode_frame_config), + (wuffs_base__status(*)(void*, + wuffs_base__image_config*, + wuffs_base__io_buffer*))(&wuffs_thumbhash__decoder__decode_image_config), + (wuffs_base__rect_ie_u32(*)(const void*))(&wuffs_thumbhash__decoder__frame_dirty_rect), + (uint64_t(*)(const void*, + uint32_t))(&wuffs_thumbhash__decoder__get_quirk), + (uint32_t(*)(const void*))(&wuffs_thumbhash__decoder__num_animation_loops), + (uint64_t(*)(const void*))(&wuffs_thumbhash__decoder__num_decoded_frame_configs), + (uint64_t(*)(const void*))(&wuffs_thumbhash__decoder__num_decoded_frames), + (wuffs_base__status(*)(void*, + uint64_t, + uint64_t))(&wuffs_thumbhash__decoder__restart_frame), + (wuffs_base__status(*)(void*, + uint32_t, + uint64_t))(&wuffs_thumbhash__decoder__set_quirk), + (wuffs_base__empty_struct(*)(void*, + uint32_t, + bool))(&wuffs_thumbhash__decoder__set_report_metadata), + (wuffs_base__status(*)(void*, + wuffs_base__io_buffer*, + wuffs_base__more_information*, + wuffs_base__io_buffer*))(&wuffs_thumbhash__decoder__tell_me_more), + (wuffs_base__range_ii_u64(*)(const void*))(&wuffs_thumbhash__decoder__workbuf_len), +}; + +// ---------------- Initializer Implementations + +wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT +wuffs_thumbhash__decoder__initialize( + wuffs_thumbhash__decoder* self, + size_t sizeof_star_self, + uint64_t wuffs_version, + uint32_t options){ + if (!self) { + return wuffs_base__make_status(wuffs_base__error__bad_receiver); + } + if (sizeof(*self) != sizeof_star_self) { + return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver); + } + if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) || + (((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) { + return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version); + } + + if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) { + // The whole point of this if-check is to detect an uninitialized *self. + // We disable the warning on GCC. Clang-5.0 does not have this warning. +#if !defined(__clang__) && defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#endif + if (self->private_impl.magic != 0) { + return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed); + } +#if !defined(__clang__) && defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) { + memset(self, 0, sizeof(*self)); + options |= WUFFS_INITIALIZE__ALREADY_ZEROED; + } else { + memset(&(self->private_impl), 0, sizeof(self->private_impl)); + } + } + + self->private_impl.magic = WUFFS_BASE__MAGIC; + self->private_impl.vtable_for__wuffs_base__image_decoder.vtable_name = + wuffs_base__image_decoder__vtable_name; + self->private_impl.vtable_for__wuffs_base__image_decoder.function_pointers = + (const void*)(&wuffs_thumbhash__decoder__func_ptrs_for__wuffs_base__image_decoder); + return wuffs_base__make_status(NULL); +} + +wuffs_thumbhash__decoder* +wuffs_thumbhash__decoder__alloc(void) { + wuffs_thumbhash__decoder* x = + (wuffs_thumbhash__decoder*)(calloc(1, sizeof(wuffs_thumbhash__decoder))); + if (!x) { + return NULL; + } + if (wuffs_thumbhash__decoder__initialize( + x, sizeof(wuffs_thumbhash__decoder), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) { + free(x); + return NULL; + } + return x; +} + +size_t +sizeof__wuffs_thumbhash__decoder(void) { + return sizeof(wuffs_thumbhash__decoder); +} + +// ---------------- Function Implementations + +// -------- func thumbhash.decoder.get_quirk + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_thumbhash__decoder__get_quirk( + const wuffs_thumbhash__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; + } + + if ((a_key == 1712283648u) && self->private_impl.f_quirk_just_raw_thumbhash) { + return 1u; + } + return 0u; +} + +// -------- func thumbhash.decoder.set_quirk + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__set_quirk( + wuffs_thumbhash__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); + } + + if (a_key == 1712283648u) { + self->private_impl.f_quirk_just_raw_thumbhash = (a_value > 0u); + return wuffs_base__make_status(NULL); + } + return wuffs_base__make_status(wuffs_base__error__unsupported_option); +} + +// -------- func thumbhash.decoder.decode_image_config + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__decode_image_config( + wuffs_thumbhash__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_thumbhash__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_thumbhash__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 thumbhash.decoder.do_decode_image_config + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__do_decode_image_config( + wuffs_thumbhash__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; + uint8_t v_swap = 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; + 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; + } + if ( ! self->private_impl.f_quirk_just_raw_thumbhash) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + uint32_t t_0; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 3)) { + t_0 = ((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.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 == 16) { + t_0 = ((uint32_t)(*scratch)); + break; + } + num_bits_0 += 8u; + *scratch |= ((uint64_t)(num_bits_0)) << 56; + } + } + v_c32 = t_0; + } + if (v_c32 != 16694979u) { + status = wuffs_base__make_status(wuffs_thumbhash__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 >= 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.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 == 16) { + 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_l_dc = (((uint64_t)(((v_c32 >> 0u) & 63u))) * 136339441844224u); + self->private_impl.f_p_dc = ((uint64_t)((((uint64_t)(((v_c32 >> 6u) & 63u))) * 272678883688448u) - 8589384836186112u)); + self->private_impl.f_q_dc = ((uint64_t)((((uint64_t)(((v_c32 >> 12u) & 63u))) * 272678883688448u) - 8589384836186112u)); + self->private_impl.f_l_scale = ((uint8_t)(((v_c32 >> 18u) & 31u))); + self->private_impl.f_has_alpha = ((uint8_t)(((v_c32 >> 23u) & 1u))); + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + uint32_t t_2; + if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 2)) { + t_2 = ((uint32_t)(wuffs_base__peek_u16le__no_bounds_check(iop_a_src))); + iop_a_src += 2; + } else { + self->private_data.s_do_decode_image_config.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.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 == 8) { + t_2 = ((uint32_t)(*scratch)); + break; + } + num_bits_2 += 8u; + *scratch |= ((uint64_t)(num_bits_2)) << 56; + } + } + v_c32 = t_2; + } + self->private_impl.f_l_count = ((uint8_t)(((v_c32 >> 0u) & 7u))); + self->private_impl.f_p_scale = ((uint8_t)(((v_c32 >> 3u) & 63u))); + self->private_impl.f_q_scale = ((uint8_t)(((v_c32 >> 9u) & 63u))); + self->private_impl.f_is_landscape = ((uint8_t)(((v_c32 >> 15u) & 1u))); + self->private_impl.f_w_dimension_code = ((uint8_t)(((uint8_t)(WUFFS_THUMBHASH__DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT[self->private_impl.f_has_alpha][self->private_impl.f_l_count] >> 4u)) & 7u)); + self->private_impl.f_h_dimension_code = ((uint8_t)(((uint8_t)(WUFFS_THUMBHASH__DIMENSION_CODES_FROM_HAS_ALPHA_AND_L_COUNT[self->private_impl.f_has_alpha][self->private_impl.f_l_count] >> 0u)) & 7u)); + if (self->private_impl.f_is_landscape != 0u) { + v_swap = self->private_impl.f_w_dimension_code; + self->private_impl.f_w_dimension_code = self->private_impl.f_h_dimension_code; + self->private_impl.f_h_dimension_code = v_swap; + } + if (self->private_impl.f_is_landscape != 0u) { + self->private_impl.f_lx = ((uint32_t)(((uint8_t)(7u - ((uint8_t)(2u * self->private_impl.f_has_alpha)))))); + self->private_impl.f_ly = ((uint32_t)(wuffs_base__u8__max(self->private_impl.f_l_count, 3u))); + } else { + self->private_impl.f_lx = ((uint32_t)(wuffs_base__u8__max(self->private_impl.f_l_count, 3u))); + self->private_impl.f_ly = ((uint32_t)(((uint8_t)(7u - ((uint8_t)(2u * self->private_impl.f_has_alpha)))))); + } + self->private_impl.f_frame_config_io_position = 8u; + if (self->private_impl.f_has_alpha != 0u) { + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + 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_3 = *iop_a_src++; + v_c32 = t_3; + } + self->private_impl.f_a_dc = (((uint64_t)(((v_c32 >> 0u) & 15u))) << 42u); + self->private_impl.f_a_scale = ((uint8_t)(((v_c32 >> 4u) & 15u))); + self->private_impl.f_frame_config_io_position = 9u; + } + if (self->private_impl.f_quirk_just_raw_thumbhash) { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + self->private_impl.f_frame_config_io_position -= 3u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } + self->private_impl.f_pixfmt = 2415954056u; + if (self->private_impl.f_has_alpha != 0u) { + self->private_impl.f_pixfmt = 2164295816u; + } + if (a_dst != NULL) { + wuffs_base__image_config__set( + a_dst, + self->private_impl.f_pixfmt, + 0u, + ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_w_dimension_code])), + ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_h_dimension_code])), + ((uint64_t)(self->private_impl.f_frame_config_io_position)), + (self->private_impl.f_has_alpha == 0u)); + } + self->private_impl.f_call_sequence = 32u; + + goto ok; + 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 thumbhash.decoder.decode_frame_config + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__decode_frame_config( + wuffs_thumbhash__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) { + { + wuffs_base__status t_0 = wuffs_thumbhash__decoder__do_decode_frame_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_thumbhash__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 thumbhash.decoder.do_decode_frame_config + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__do_decode_frame_config( + wuffs_thumbhash__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_thumbhash__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 (((uint64_t)(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) { + wuffs_base__frame_config__set( + a_dst, + wuffs_base__utility__make_rect_ie_u32( + 0u, + 0u, + ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_w_dimension_code])), + ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_h_dimension_code]))), + ((wuffs_base__flicks)(0u)), + 0u, + ((uint64_t)(self->private_impl.f_frame_config_io_position)), + 0u, + (self->private_impl.f_has_alpha == 0u), + 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 thumbhash.decoder.decode_frame + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__decode_frame( + wuffs_thumbhash__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_thumbhash__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_thumbhash__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 thumbhash.decoder.do_decode_frame + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__do_decode_frame( + wuffs_thumbhash__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); + + wuffs_base__status v_status = wuffs_base__make_status(NULL); + + 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) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); + status = wuffs_thumbhash__decoder__do_decode_frame_config(self, NULL, a_src); + if (status.repr) { + goto suspend; + } + } else { + status = wuffs_base__make_status(wuffs_base__note__end_of_data); + goto ok; + } + 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(a_dst), + wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt), + wuffs_base__utility__empty_slice_u8(), + a_blend); + 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; + } + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + status = wuffs_thumbhash__decoder__from_src_to_coeffs(self, a_src); + if (status.repr) { + goto suspend; + } + wuffs_thumbhash__decoder__from_coeffs_to_pixels(self); + v_status = wuffs_thumbhash__decoder__from_pixels_to_dst(self, a_dst); + 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; + } + self->private_impl.f_call_sequence = 96u; + + 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: + return status; +} + +// -------- func thumbhash.decoder.from_src_to_coeffs + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__from_src_to_coeffs( + wuffs_thumbhash__decoder* self, + wuffs_base__io_buffer* a_src) { + wuffs_base__status status = wuffs_base__make_status(NULL); + + uint8_t v_c8 = 0; + uint32_t v_cy = 0; + uint32_t v_cx = 0; + uint32_t v_i = 0; + bool v_has_bits = false; + + 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_from_src_to_coeffs; + if (coro_susp_point) { + v_cy = self->private_data.s_from_src_to_coeffs.v_cy; + v_cx = self->private_data.s_from_src_to_coeffs.v_cx; + v_i = self->private_data.s_from_src_to_coeffs.v_i; + v_has_bits = self->private_data.s_from_src_to_coeffs.v_has_bits; + } + switch (coro_susp_point) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + + v_i = 0u; + v_cy = 0u; + while (v_cy < self->private_impl.f_ly) { + v_cx = 0u; + if (v_cy == 0u) { + v_cx = 1u; + } + while (((uint32_t)(v_cx * self->private_impl.f_ly)) < ((uint32_t)(self->private_impl.f_lx * ((uint32_t)(self->private_impl.f_ly - v_cy))))) { + if (v_has_bits) { + v_has_bits = false; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_c8 >>= 4u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + v_has_bits = true; + { + 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++; + v_c8 = t_0; + } + } + self->private_data.f_lac[(v_i & 31u)] = ((uint32_t)(((uint32_t)(((uint32_t)(self->private_impl.f_l_scale)) * 126u)) * wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__FROM_4_BITS_TO_PLUS_MINUS_1_00[((uint8_t)(v_c8 & 15u))]))); + v_i += 1u; + v_cx += 1u; + } + v_cy += 1u; + } + v_i = 0u; + v_cx = 0u; + while (v_cx < 5u) { + if (v_has_bits) { + v_has_bits = false; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_c8 >>= 4u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + v_has_bits = true; + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2); + 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_1 = *iop_a_src++; + v_c8 = t_1; + } + } + self->private_data.f_pac[(v_i & 7u)] = ((uint32_t)(((uint32_t)(((uint32_t)(self->private_impl.f_p_scale)) * 62u)) * wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__FROM_4_BITS_TO_PLUS_MINUS_1_25[((uint8_t)(v_c8 & 15u))]))); + v_i += 1u; + v_cx += 1u; + } + v_i = 0u; + v_cx = 0u; + while (v_cx < 5u) { + if (v_has_bits) { + v_has_bits = false; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_c8 >>= 4u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + v_has_bits = true; + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3); + 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_2 = *iop_a_src++; + v_c8 = t_2; + } + } + self->private_data.f_qac[(v_i & 7u)] = ((uint32_t)(((uint32_t)(((uint32_t)(self->private_impl.f_q_scale)) * 62u)) * wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__FROM_4_BITS_TO_PLUS_MINUS_1_25[((uint8_t)(v_c8 & 15u))]))); + v_i += 1u; + v_cx += 1u; + } + if (self->private_impl.f_has_alpha == 0u) { + status = wuffs_base__make_status(NULL); + goto ok; + } + v_i = 0u; + v_cx = 0u; + while (v_cx < 14u) { + if (v_has_bits) { + v_has_bits = false; +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + v_c8 >>= 4u; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif + } else { + v_has_bits = true; + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4); + 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_3 = *iop_a_src++; + v_c8 = t_3; + } + } + self->private_data.f_aac[(v_i & 15u)] = ((uint32_t)(((uint32_t)(((uint32_t)(self->private_impl.f_a_scale)) * 2u)) * wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__FROM_4_BITS_TO_PLUS_MINUS_1_00[((uint8_t)(v_c8 & 15u))]))); + v_i += 1u; + v_cx += 1u; + } + + ok: + self->private_impl.p_from_src_to_coeffs = 0; + goto exit; + } + + goto suspend; + suspend: + self->private_impl.p_from_src_to_coeffs = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0; + self->private_data.s_from_src_to_coeffs.v_cy = v_cy; + self->private_data.s_from_src_to_coeffs.v_cx = v_cx; + self->private_data.s_from_src_to_coeffs.v_i = v_i; + self->private_data.s_from_src_to_coeffs.v_has_bits = v_has_bits; + + 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 thumbhash.decoder.from_coeffs_to_pixels + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__empty_struct +wuffs_thumbhash__decoder__from_coeffs_to_pixels( + wuffs_thumbhash__decoder* self) { + uint32_t v_h = 0; + uint32_t v_w = 0; + uint32_t v_fy[8] = {0}; + uint32_t v_fx[8] = {0}; + uint32_t v_cosines_base_y = 0; + uint32_t v_cosines_base_x = 0; + uint32_t v_y = 0; + uint32_t v_x = 0; + uint32_t v_f = 0; + uint64_t v_l = 0; + uint64_t v_p = 0; + uint64_t v_q = 0; + uint64_t v_b = 0; + uint64_t v_g = 0; + uint64_t v_r = 0; + uint64_t v_a = 0; + uint32_t v_i = 0; + uint32_t v_cy = 0; + uint32_t v_cx = 0; + + v_h = ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_h_dimension_code])); + v_w = ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_w_dimension_code])); + v_fy[0u] = 16384u; + v_fx[0u] = 16384u; + v_a = 255u; + v_y = 0u; + while (v_y < v_h) { + v_cosines_base_y = ((uint32_t)(WUFFS_THUMBHASH__CUMULATIVE_DIMENSIONS[self->private_impl.f_h_dimension_code])); + v_fy[1u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_y + v_y)][0u]); + v_fy[2u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_y + v_y)][1u]); + v_fy[3u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_y + v_y)][2u]); + v_fy[4u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_y + v_y)][3u]); + v_fy[5u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_y + v_y)][4u]); + v_fy[6u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_y + v_y)][5u]); + v_x = 0u; + while (v_x < v_w) { + v_cosines_base_x = ((uint32_t)(WUFFS_THUMBHASH__CUMULATIVE_DIMENSIONS[self->private_impl.f_w_dimension_code])); + v_fx[1u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_x + v_x)][0u]); + v_fx[2u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_x + v_x)][1u]); + v_fx[3u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_x + v_x)][2u]); + v_fx[4u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_x + v_x)][3u]); + v_fx[5u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_x + v_x)][4u]); + v_fx[6u] = wuffs_base__utility__sign_extend_convert_u16_u32(WUFFS_THUMBHASH__COSINES[(v_cosines_base_x + v_x)][5u]); + v_l = self->private_impl.f_l_dc; + v_i = 0u; + v_cy = 0u; + while (v_cy < self->private_impl.f_ly) { + v_cx = 0u; + if (v_cy == 0u) { + v_cx = 1u; + } + while (((uint32_t)(v_cx * self->private_impl.f_ly)) < ((uint32_t)(self->private_impl.f_lx * ((uint32_t)(self->private_impl.f_ly - v_cy))))) { + v_f = ((uint32_t)(v_fx[(v_cx & 7u)] * v_fy[(v_cy & 7u)])); + v_l += ((uint64_t)(wuffs_base__utility__sign_extend_convert_u32_u64(v_f) * wuffs_base__utility__sign_extend_convert_u32_u64(self->private_data.f_lac[(v_i & 31u)]))); + v_i += 1u; + v_cx += 1u; + } + v_cy += 1u; + } + v_p = self->private_impl.f_p_dc; + v_q = self->private_impl.f_q_dc; + v_i = 0u; + v_cy = 0u; + while (v_cy < 3u) { + v_cx = 0u; + if (v_cy == 0u) { + v_cx = 1u; + } + while (v_cx < (3u - v_cy)) { + v_f = ((uint32_t)(v_fx[v_cx] * v_fy[v_cy])); + v_p += ((uint64_t)(wuffs_base__utility__sign_extend_convert_u32_u64(v_f) * wuffs_base__utility__sign_extend_convert_u32_u64(self->private_data.f_pac[(v_i & 7u)]))); + v_q += ((uint64_t)(wuffs_base__utility__sign_extend_convert_u32_u64(v_f) * wuffs_base__utility__sign_extend_convert_u32_u64(self->private_data.f_qac[(v_i & 7u)]))); + v_i += 1u; + v_cx += 1u; + } + v_cy += 1u; + } + v_b = ((uint64_t)(v_l - wuffs_base__utility__i64_divide(((uint64_t)(2u * v_p)), 3u))); + v_r = wuffs_base__utility__sign_extend_rshift_u64(((uint64_t)(((uint64_t)(((uint64_t)(3u * v_l)) + v_q)) - v_b)), 1u); + v_g = ((uint64_t)(v_r - v_q)); + if ((v_b >> 63u) != 0u) { + v_b = 0u; + } else if (v_b >= 8589384836185950u) { + v_b = 255u; + } else { + v_b /= 33683862102690u; + } + if ((v_g >> 63u) != 0u) { + v_g = 0u; + } else if (v_g >= 8589384836185950u) { + v_g = 255u; + } else { + v_g /= 33683862102690u; + } + if ((v_r >> 63u) != 0u) { + v_r = 0u; + } else if (v_r >= 8589384836185950u) { + v_r = 255u; + } else { + v_r /= 33683862102690u; + } + if (self->private_impl.f_has_alpha != 0u) { + v_a = self->private_impl.f_a_dc; + v_i = 0u; + v_cy = 0u; + while (v_cy < 5u) { + v_cx = 0u; + if (v_cy == 0u) { + v_cx = 1u; + } + while (v_cx < (5u - v_cy)) { + v_f = ((uint32_t)(v_fx[v_cx] * v_fy[v_cy])); + v_a += ((uint64_t)(wuffs_base__utility__sign_extend_convert_u32_u64(v_f) * wuffs_base__utility__sign_extend_convert_u32_u64(self->private_data.f_aac[(v_i & 15u)]))); + v_i += 1u; + v_cx += 1u; + } + v_cy += 1u; + } + if ((v_a >> 63u) != 0u) { + v_a = 0u; + } else if (v_a >= 65970697666500u) { + v_a = 255u; + } else { + v_a /= 258708618300u; + } + } + self->private_data.f_pixels[v_y][((4u * v_x) + 0u)] = ((uint8_t)(v_b)); + self->private_data.f_pixels[v_y][((4u * v_x) + 1u)] = ((uint8_t)(v_g)); + self->private_data.f_pixels[v_y][((4u * v_x) + 2u)] = ((uint8_t)(v_r)); + self->private_data.f_pixels[v_y][((4u * v_x) + 3u)] = ((uint8_t)(v_a)); + v_x += 1u; + } + v_y += 1u; + } + return wuffs_base__make_empty_struct(); +} + +// -------- func thumbhash.decoder.from_pixels_to_dst + +WUFFS_BASE__GENERATED_C_CODE +static wuffs_base__status +wuffs_thumbhash__decoder__from_pixels_to_dst( + wuffs_thumbhash__decoder* self, + wuffs_base__pixel_buffer* a_dst) { + uint32_t v_h = 0; + uint32_t v_w = 0; + wuffs_base__pixel_format v_dst_pixfmt = {0}; + uint32_t v_dst_bits_per_pixel = 0; + uint32_t v_dst_bytes_per_pixel = 0; + uint64_t v_dst_bytes_per_row = 0; + wuffs_base__table_u8 v_tab = {0}; + uint32_t v_y = 0; + wuffs_base__slice_u8 v_dst = {0}; + wuffs_base__slice_u8 v_src = {0}; + + v_h = ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_h_dimension_code])); + v_w = ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_w_dimension_code])); + v_dst_pixfmt = wuffs_base__pixel_buffer__pixel_format(a_dst); + v_dst_bits_per_pixel = wuffs_base__pixel_format__bits_per_pixel(&v_dst_pixfmt); + if ((v_dst_bits_per_pixel & 7u) != 0u) { + return wuffs_base__make_status(wuffs_base__error__unsupported_option); + } + v_dst_bytes_per_pixel = (v_dst_bits_per_pixel / 8u); + v_dst_bytes_per_row = ((uint64_t)((v_w * v_dst_bytes_per_pixel))); + v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u); + while (v_y < v_h) { + v_src = wuffs_base__make_slice_u8(self->private_data.f_pixels[v_y], (v_w * 4u)); + v_dst = wuffs_private_impl__table_u8__row_u32(v_tab, v_y); + if (v_dst_bytes_per_row < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_dst_bytes_per_row); + } + wuffs_base__pixel_swizzler__swizzle_interleaved_from_slice(&self->private_impl.f_swizzler, v_dst, wuffs_base__pixel_buffer__palette(a_dst), v_src); + v_y += 1u; + } + return wuffs_base__make_status(NULL); +} + +// -------- func thumbhash.decoder.frame_dirty_rect + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__rect_ie_u32 +wuffs_thumbhash__decoder__frame_dirty_rect( + const wuffs_thumbhash__decoder* self) { + if (!self) { + return wuffs_base__utility__empty_rect_ie_u32(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_rect_ie_u32(); + } + + return wuffs_base__utility__make_rect_ie_u32( + 0u, + 0u, + ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_w_dimension_code])), + ((uint32_t)(WUFFS_THUMBHASH__DIMENSIONS_FROM_DIMENSION_CODES[self->private_impl.f_h_dimension_code]))); +} + +// -------- func thumbhash.decoder.num_animation_loops + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint32_t +wuffs_thumbhash__decoder__num_animation_loops( + const wuffs_thumbhash__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + return 0u; +} + +// -------- func thumbhash.decoder.num_decoded_frame_configs + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_thumbhash__decoder__num_decoded_frame_configs( + const wuffs_thumbhash__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + if (self->private_impl.f_call_sequence > 32u) { + return 1u; + } + return 0u; +} + +// -------- func thumbhash.decoder.num_decoded_frames + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC uint64_t +wuffs_thumbhash__decoder__num_decoded_frames( + const wuffs_thumbhash__decoder* self) { + if (!self) { + return 0; + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return 0; + } + + if (self->private_impl.f_call_sequence > 64u) { + return 1u; + } + return 0u; +} + +// -------- func thumbhash.decoder.restart_frame + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__restart_frame( + wuffs_thumbhash__decoder* self, + uint64_t a_index, + uint64_t a_io_position) { + 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 (self->private_impl.f_call_sequence < 32u) { + return wuffs_base__make_status(wuffs_base__error__bad_call_sequence); + } + if ((a_index != 0u) || (a_io_position != ((uint64_t)(self->private_impl.f_frame_config_io_position)))) { + return wuffs_base__make_status(wuffs_base__error__bad_argument); + } + self->private_impl.f_call_sequence = 40u; + return wuffs_base__make_status(NULL); +} + +// -------- func thumbhash.decoder.set_report_metadata + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct +wuffs_thumbhash__decoder__set_report_metadata( + wuffs_thumbhash__decoder* self, + uint32_t a_fourcc, + bool a_report) { + return wuffs_base__make_empty_struct(); +} + +// -------- func thumbhash.decoder.tell_me_more + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__status +wuffs_thumbhash__decoder__tell_me_more( + wuffs_thumbhash__decoder* self, + wuffs_base__io_buffer* a_dst, + wuffs_base__more_information* a_minfo, + 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_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 != 4)) { + 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); + + status = wuffs_base__make_status(wuffs_base__error__no_more_information); + goto exit; + + goto ok; + ok: + goto exit; + exit: + if (wuffs_base__status__is_error(&status)) { + self->private_impl.magic = WUFFS_BASE__DISABLED; + } + return status; +} + +// -------- func thumbhash.decoder.workbuf_len + +WUFFS_BASE__GENERATED_C_CODE +WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 +wuffs_thumbhash__decoder__workbuf_len( + const wuffs_thumbhash__decoder* self) { + if (!self) { + return wuffs_base__utility__empty_range_ii_u64(); + } + if ((self->private_impl.magic != WUFFS_BASE__MAGIC) && + (self->private_impl.magic != WUFFS_BASE__DISABLED)) { + return wuffs_base__utility__empty_range_ii_u64(); + } + + return wuffs_base__utility__make_range_ii_u64(0u, 0u); +} + +#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__VP8) @@ -76420,7 +81792,7 @@ 4u, 4u, 0u, 0u, 4u, 4u, 0u, 0u, }; -#define WUFFS_XZ__QUIRKS_BASE 2021322752u +#define WUFFS_XZ__QUIRKS_BASE 1963655168u static const uint8_t WUFFS_XZ__CHECKSUM_LENGTH[4] WUFFS_BASE__POTENTIALLY_UNUSED = { @@ -77164,7 +82536,7 @@ if (self->private_impl.f_ignore_checksum) { return 1u; } - } else if (a_key == 2021322752u) { + } else if (a_key == 1963655168u) { if (self->private_impl.f_standalone_format) { return 1u; } @@ -77193,7 +82565,7 @@ if (a_key == 1u) { self->private_impl.f_ignore_checksum = (a_value > 0u); return wuffs_base__make_status(NULL); - } else if (a_key == 2021322752u) { + } else if (a_key == 1963655168u) { self->private_impl.f_standalone_format = (a_value > 0u); return wuffs_base__make_status(NULL); } @@ -78517,7 +83889,7 @@ uint8_t t_10 = *iop_a_src++; v_c8 = t_10; } - v_status = wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1348001793u, (2u | (((uint64_t)(v_c8)) << 8u))); + v_status = wuffs_lzma__decoder__set_quirk(&self->private_data.f_lzma, 1290294273u, (2u | (((uint64_t)(v_c8)) << 8u))); if ( ! wuffs_base__status__is_ok(&v_status)) { status = wuffs_base__make_status(wuffs_xz__error__bad_filter); goto exit; @@ -79582,6 +84954,11 @@ return wuffs_bmp__decoder::alloc_as__wuffs_base__image_decoder(); #endif +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) + case WUFFS_BASE__FOURCC__ETC2: + return wuffs_etc2__decoder::alloc_as__wuffs_base__image_decoder(); +#endif + #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) case WUFFS_BASE__FOURCC__GIF: return wuffs_gif__decoder::alloc_as__wuffs_base__image_decoder(); @@ -79616,9 +84993,14 @@ return wuffs_qoi__decoder::alloc_as__wuffs_base__image_decoder(); #endif -#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) case WUFFS_BASE__FOURCC__TGA: - return wuffs_tga__decoder::alloc_as__wuffs_base__image_decoder(); + return wuffs_targa__decoder::alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) + case WUFFS_BASE__FOURCC__TH: + return wuffs_thumbhash__decoder::alloc_as__wuffs_base__image_decoder(); #endif #if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) @@ -79985,6 +85367,7 @@ wuffs_base__pixel_format pixel_format = callbacks.SelectPixfmt(image_config); if (pixel_format.repr != image_config.pixcfg.pixel_format().repr) { switch (pixel_format.repr) { + case WUFFS_BASE__PIXEL_FORMAT__Y: case WUFFS_BASE__PIXEL_FORMAT__BGR_565: case WUFFS_BASE__PIXEL_FORMAT__BGR: case WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL: @@ -80738,6 +86121,537 @@ #endif // defined(__cplusplus) && defined(WUFFS_BASE__HAVE_UNIQUE_PTR) + +// ---------------- Wuffs' reimplementation of the STB API. +// +// This is a drop-in replacement of that third-party library. +// +// Disabled by default, unless you #define the +// WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB macro beforehand. +// +// For API docs, see https://github.com/nothings/stb + +#if defined(WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB) + +#include <limits.h> +#include <stdlib.h> + +#ifdef __cplusplus +extern "C" { +#endif + +// -------- + +#if defined(__GNUC__) +__thread const char* // + wuffs_drop_in__stb__g_failure_reason = NULL; +#elif defined(_MSC_VER) +__declspec(thread) const char* // + wuffs_drop_in__stb__g_failure_reason = NULL; +#else +const char* // + wuffs_drop_in__stb__g_failure_reason = NULL; +#endif + +// -------- + +static void // +wuffs_drop_in__stb__read( // + wuffs_base__io_buffer* srcbuf, // + stbi_io_callbacks const* clbk, // + void* user) { + uint8_t* ptr = wuffs_base__io_buffer__writer_pointer(srcbuf); + size_t len = wuffs_base__io_buffer__writer_length(srcbuf); + if (len > INT_MAX) { + len = INT_MAX; + } + int n = clbk->read(user, (char*)ptr, (int)len); + if (n > 0) { + srcbuf->meta.wi += (size_t)n; + } else { + srcbuf->meta.closed = clbk->eof(user); + } +} + +static wuffs_base__image_decoder* // +wuffs_drop_in__stb__make_decoder( // + wuffs_base__io_buffer* srcbuf, // + stbi_io_callbacks const* clbk, // + void* user) { + while (1) { + int32_t fourcc = wuffs_base__magic_number_guess_fourcc( + wuffs_base__io_buffer__reader_slice(srcbuf), srcbuf->meta.closed); + if (fourcc < 0) { + if (srcbuf->meta.closed || !clbk) { + break; + } + wuffs_drop_in__stb__read(srcbuf, clbk, user); + continue; + } + + switch (fourcc) { +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__BMP) + case WUFFS_BASE__FOURCC__BMP: + return wuffs_bmp__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__ETC2) + case WUFFS_BASE__FOURCC__ETC2: + return wuffs_etc2__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__GIF) + case WUFFS_BASE__FOURCC__GIF: + return wuffs_gif__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__JPEG) + case WUFFS_BASE__FOURCC__JPEG: + return wuffs_jpeg__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NIE) + case WUFFS_BASE__FOURCC__NIE: + return wuffs_nie__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__NETPBM) + case WUFFS_BASE__FOURCC__NPBM: + return wuffs_netpbm__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG) + case WUFFS_BASE__FOURCC__PNG: + return wuffs_png__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__QOI) + case WUFFS_BASE__FOURCC__QOI: + return wuffs_qoi__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TARGA) + case WUFFS_BASE__FOURCC__TGA: + return wuffs_targa__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__THUMBHASH) + case WUFFS_BASE__FOURCC__TH: + return wuffs_thumbhash__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WBMP) + case WUFFS_BASE__FOURCC__WBMP: + return wuffs_wbmp__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + +#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP) + case WUFFS_BASE__FOURCC__WEBP: + return wuffs_webp__decoder__alloc_as__wuffs_base__image_decoder(); +#endif + } + + wuffs_drop_in__stb__g_failure_reason = "unknown image type"; + break; + } + return NULL; +} + +// -------- + +static void* // +wuffs_drop_in__stb__load1( // + wuffs_base__io_buffer* srcbuf, // + stbi_io_callbacks const* clbk, // + void* user, // + wuffs_base__image_decoder* dec, // + wuffs_base__image_config* ic, // + uint32_t dst_pixfmt, // + int desired_channels, // + int info_only) { + // Favor faster decodes over rejecting invalid checksums. + wuffs_base__image_decoder__set_quirk(dec, WUFFS_BASE__QUIRK_IGNORE_CHECKSUM, + 1); + + while (1) { + wuffs_base__status status = + wuffs_base__image_decoder__decode_image_config(dec, ic, srcbuf); + if (status.repr == NULL) { + break; + } else if ((status.repr != wuffs_base__suspension__short_read) || !clbk) { + wuffs_drop_in__stb__g_failure_reason = status.repr; + return NULL; + } + + size_t wl = wuffs_base__io_buffer__writer_length(srcbuf); + wuffs_base__io_buffer__compact(srcbuf); + if (wl >= wuffs_base__io_buffer__writer_length(srcbuf)) { + wuffs_drop_in__stb__g_failure_reason = "I/O buffer is too small"; + return NULL; + } + wuffs_drop_in__stb__read(srcbuf, clbk, user); + } + + uint32_t w = wuffs_base__pixel_config__width(&ic->pixcfg); + uint32_t h = wuffs_base__pixel_config__height(&ic->pixcfg); + if ((w > 0xFFFFFF) || (h > 0xFFFFFF)) { + wuffs_drop_in__stb__g_failure_reason = "image is too large"; + return NULL; + } else if (info_only) { + return NULL; + } + + 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; +#if SIZE_MAX < 0xFFFFFFFFFFFFFFFFull + if ((pixbuf_len > ((uint64_t)SIZE_MAX)) || + (workbuf_len > ((uint64_t)SIZE_MAX))) { + wuffs_drop_in__stb__g_failure_reason = "image is too large"; + return NULL; + } +#endif + void* pixbuf_ptr = malloc((size_t)pixbuf_len); + if (!pixbuf_ptr) { + wuffs_drop_in__stb__g_failure_reason = "out of memory"; + return NULL; + } + void* workbuf_ptr = malloc((size_t)workbuf_len); + if (!workbuf_ptr) { + free(pixbuf_ptr); + wuffs_drop_in__stb__g_failure_reason = "out of memory"; + return NULL; + } + wuffs_base__slice_u8 workbuf = + wuffs_base__make_slice_u8(workbuf_ptr, (size_t)workbuf_len); + + wuffs_base__pixel_config pc = ((wuffs_base__pixel_config){}); + wuffs_base__pixel_config__set(&pc, dst_pixfmt, + WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h); + + wuffs_base__pixel_buffer pb = ((wuffs_base__pixel_buffer){}); + { + wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice( + &pb, &pc, wuffs_base__make_slice_u8(pixbuf_ptr, (size_t)pixbuf_len)); + if (status.repr) { + free(workbuf_ptr); + free(pixbuf_ptr); + wuffs_drop_in__stb__g_failure_reason = status.repr; + return NULL; + } + } + + while (1) { + wuffs_base__status status = wuffs_base__image_decoder__decode_frame( + dec, &pb, srcbuf, WUFFS_BASE__PIXEL_BLEND__SRC, workbuf, NULL); + if (status.repr == NULL) { + break; + } else if ((status.repr != wuffs_base__suspension__short_read) || !clbk) { + free(workbuf_ptr); + free(pixbuf_ptr); + wuffs_drop_in__stb__g_failure_reason = status.repr; + return NULL; + } + + size_t wl = wuffs_base__io_buffer__writer_length(srcbuf); + wuffs_base__io_buffer__compact(srcbuf); + if (wl >= wuffs_base__io_buffer__writer_length(srcbuf)) { + free(workbuf_ptr); + free(pixbuf_ptr); + wuffs_drop_in__stb__g_failure_reason = "I/O buffer is too small"; + return NULL; + } + wuffs_drop_in__stb__read(srcbuf, clbk, user); + } + + free(workbuf_ptr); + return pixbuf_ptr; +} + +static void* // +wuffs_drop_in__stb__load0( // + wuffs_base__io_buffer* srcbuf, // + stbi_io_callbacks const* clbk, // + void* user, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels, // + int info_only) { + uint32_t dst_pixfmt = 0; + switch (desired_channels) { + case 1: + dst_pixfmt = WUFFS_BASE__PIXEL_FORMAT__Y; + break; + case 3: + dst_pixfmt = WUFFS_BASE__PIXEL_FORMAT__RGB; + break; + case 4: + dst_pixfmt = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL; + break; + default: + wuffs_drop_in__stb__g_failure_reason = "unsupported format conversion"; + return NULL; + } + + wuffs_base__image_decoder* dec = + wuffs_drop_in__stb__make_decoder(srcbuf, clbk, user); + if (!dec) { + if (wuffs_drop_in__stb__g_failure_reason == NULL) { + wuffs_drop_in__stb__g_failure_reason = "couldn't allocate image decoder"; + } + return NULL; + } + + wuffs_base__image_config ic = ((wuffs_base__image_config){}); + stbi_uc* ret = wuffs_drop_in__stb__load1( + srcbuf, clbk, user, dec, &ic, dst_pixfmt, desired_channels, info_only); + free(dec); + + if (!info_only && !ret) { + return NULL; + } + + if (x) { + *x = (int)wuffs_base__pixel_config__width(&ic.pixcfg); + } + if (y) { + *y = (int)wuffs_base__pixel_config__height(&ic.pixcfg); + } + if (channels_in_file) { + wuffs_base__pixel_format src_pixfmt = + wuffs_base__pixel_config__pixel_format(&ic.pixcfg); + uint32_t n_color = wuffs_base__pixel_format__coloration(&src_pixfmt); + uint32_t n_alpha = wuffs_base__pixel_format__transparency(&src_pixfmt) != + WUFFS_BASE__PIXEL_ALPHA_TRANSPARENCY__OPAQUE; + *channels_in_file = (int)(n_color + n_alpha); + } + + return ret; +} + +// -------- + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info_from_memory( // + stbi_uc const* buffer, // + int len, // + int* x, // + int* y, // + int* comp) { + wuffs_drop_in__stb__g_failure_reason = NULL; + if (len < 0) { + wuffs_drop_in__stb__g_failure_reason = "negative buffer length"; + return 0; + } else if (len == 0) { + wuffs_drop_in__stb__g_failure_reason = "empty buffer"; + return 0; + } + wuffs_base__io_buffer srcbuf = + wuffs_base__ptr_u8__reader((uint8_t*)(stbi_uc*)buffer, (size_t)len, true); + wuffs_drop_in__stb__load0(&srcbuf, NULL, NULL, x, y, comp, 1, 1); + return wuffs_drop_in__stb__g_failure_reason == NULL; +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load_from_memory( // + stbi_uc const* buffer, // + int len, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels) { + wuffs_drop_in__stb__g_failure_reason = NULL; + if (len < 0) { + wuffs_drop_in__stb__g_failure_reason = "negative buffer length"; + return NULL; + } else if (len == 0) { + wuffs_drop_in__stb__g_failure_reason = "empty buffer"; + return NULL; + } + wuffs_base__io_buffer srcbuf = + wuffs_base__ptr_u8__reader((uint8_t*)(stbi_uc*)buffer, (size_t)len, true); + return wuffs_drop_in__stb__load0(&srcbuf, NULL, NULL, x, y, channels_in_file, + desired_channels, 0); +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info_from_callbacks( // + stbi_io_callbacks const* clbk, // + void* user, // + int* x, // + int* y, // + int* comp) { + wuffs_drop_in__stb__g_failure_reason = NULL; + void* iobuf_ptr = malloc(65536u); + if (!iobuf_ptr) { + wuffs_drop_in__stb__g_failure_reason = "out of memory"; + return 0; + } + wuffs_base__io_buffer srcbuf = + wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); + wuffs_drop_in__stb__load0(&srcbuf, clbk, user, x, y, comp, 1, 1); + free(iobuf_ptr); + return wuffs_drop_in__stb__g_failure_reason == NULL; +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load_from_callbacks( // + stbi_io_callbacks const* clbk, // + void* user, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels) { + wuffs_drop_in__stb__g_failure_reason = NULL; + void* iobuf_ptr = malloc(65536u); + if (!iobuf_ptr) { + wuffs_drop_in__stb__g_failure_reason = "out of memory"; + return NULL; + } + wuffs_base__io_buffer srcbuf = + wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); + stbi_uc* ret = wuffs_drop_in__stb__load0( + &srcbuf, clbk, user, x, y, channels_in_file, desired_channels, 0); + free(iobuf_ptr); + return ret; +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC void // +stbi_image_free( // + void* retval_from_stbi_load) { + wuffs_drop_in__stb__g_failure_reason = NULL; + free(retval_from_stbi_load); +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC const char* // +stbi_failure_reason(void) { + return wuffs_drop_in__stb__g_failure_reason + ? wuffs_drop_in__stb__g_failure_reason + : "ok"; +} + +// -------- + +#if !defined(STBI_NO_STDIO) + +#include <stdio.h> + +// TODO: retry after EINTR? + +static int // +wuffs_drop_in__stb__file_callbacks__read( // + void* user, // + char* data, // + int size) { + return (int)fread(data, 1u, (size_t)size, (FILE*)user); +} + +static void // +wuffs_drop_in__stb__file_callbacks__skip( // + void* user, // + int n) { + fseek((FILE*)user, (long)n, SEEK_CUR); +} + +static int // +wuffs_drop_in__stb__file_callbacks__eof( // + void* user) { + return feof((FILE*)user); +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info( // + char const* filename, // + int* x, // + int* y, // + int* comp) { + wuffs_drop_in__stb__g_failure_reason = NULL; + FILE* f = fopen(filename, "rb"); + if (!f) { + wuffs_drop_in__stb__g_failure_reason = "could not open file"; + return 0; + } + int ret = stbi_info_from_file(f, x, y, comp); + fclose(f); + return ret; +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load( // + char const* filename, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels) { + wuffs_drop_in__stb__g_failure_reason = NULL; + FILE* f = fopen(filename, "rb"); + if (!f) { + wuffs_drop_in__stb__g_failure_reason = "could not open file"; + return NULL; + } + stbi_uc* ret = + stbi_load_from_file(f, x, y, channels_in_file, desired_channels); + fclose(f); + return ret; +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC int // +stbi_info_from_file( // + FILE* f, // + int* x, // + int* y, // + int* comp) { + wuffs_drop_in__stb__g_failure_reason = NULL; + void* iobuf_ptr = malloc(65536u); + if (!iobuf_ptr) { + wuffs_drop_in__stb__g_failure_reason = "out of memory"; + return 0; + } + wuffs_base__io_buffer srcbuf = + wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); + stbi_io_callbacks clbk; + clbk.read = &wuffs_drop_in__stb__file_callbacks__read; + clbk.skip = &wuffs_drop_in__stb__file_callbacks__skip; + clbk.eof = &wuffs_drop_in__stb__file_callbacks__eof; + wuffs_drop_in__stb__load0(&srcbuf, &clbk, f, x, y, comp, 1, 1); + free(iobuf_ptr); + return wuffs_drop_in__stb__g_failure_reason == NULL; +} + +WUFFS_DROP_IN__STB__MAYBE_STATIC stbi_uc* // +stbi_load_from_file( // + FILE* f, // + int* x, // + int* y, // + int* channels_in_file, // + int desired_channels) { + wuffs_drop_in__stb__g_failure_reason = NULL; + void* iobuf_ptr = malloc(65536u); + if (!iobuf_ptr) { + wuffs_drop_in__stb__g_failure_reason = "out of memory"; + return NULL; + } + wuffs_base__io_buffer srcbuf = + wuffs_base__ptr_u8__writer((uint8_t*)iobuf_ptr, 65536u); + stbi_io_callbacks clbk; + clbk.read = &wuffs_drop_in__stb__file_callbacks__read; + clbk.skip = &wuffs_drop_in__stb__file_callbacks__skip; + clbk.eof = &wuffs_drop_in__stb__file_callbacks__eof; + stbi_uc* ret = wuffs_drop_in__stb__load0( + &srcbuf, &clbk, f, x, y, channels_in_file, desired_channels, 0); + free(iobuf_ptr); + return ret; +} + +#endif // !defined(STBI_NO_STDIO) + +// -------- + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // defined (WUFFS_CONFIG__ENABLE_DROP_IN_REPLACEMENT__STB) #endif // WUFFS_IMPLEMENTATION #if defined(__GNUC__)
diff --git a/sync.txt b/sync.txt index 4906f2b..a176975 100644 --- a/sync.txt +++ b/sync.txt
@@ -1,10 +1,10 @@ -script/sync.sh ran on 2024-08-13 -Sibling directory (../wuffs) git revision is beaf45650085a16780b5f708b72daaeb1aa865c8 +script/sync.sh ran on 2024-09-14 +Sibling directory (../wuffs) git revision is 3387e19512ba52957f29fa3a357f11360b415b08 Manifest (sha256sum values, filenames, versions): 994126492f24a3edae9b95efa92820647cedc42ee933ce3ff2a364fa9c62aba3 release/c/README.md 3b6a0c78f663bb495d1972fbb2a87c717d70fbac5ea8cc1a50cb9afaa4b03f92 release/c/wuffs-v0.2.c #define WUFFS_VERSION_STRING "0.2.0+2078.20191219" a3db4bd979663423de00309d1ba07d7fa8576845223d3e02764181bd6da23f90 release/c/wuffs-v0.3.c #define WUFFS_VERSION_STRING "0.3.4+3401.20240419" -6c22caff4af929112601379a73f72461bc4719a5215366bcc90d599cbc442bb6 release/c/wuffs-v0.4.c - #define WUFFS_VERSION_STRING "0.4.0-alpha.8+3796.20240812" +51d2f73b757adfab105386fd3641aebd69dabc3a19126d5e060b6996ede94714 release/c/wuffs-v0.4.c + #define WUFFS_VERSION_STRING "0.4.0-alpha.9+3837.20240914"