mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-21 00:47:28 +01:00
std/webp: implement VP8 Lossless
This commit is contained in:
1 parent
09f4500e19
commit
00e6e71672
8 files changed
+5778
-83
No files matched your search
@@ -13742,7 +13742,18 @@ struct wuffs_wbmp__decoder__struct {
|
||||
|
||||
// ---------------- Status Codes
|
||||
|
||||
extern const char wuffs_webp__error__bad_huffman_code_over_subscribed[];
|
||||
extern const char wuffs_webp__error__bad_huffman_code_under_subscribed[];
|
||||
extern const char wuffs_webp__error__bad_huffman_code[];
|
||||
extern const char wuffs_webp__error__bad_back_reference[];
|
||||
extern const char wuffs_webp__error__bad_color_cache[];
|
||||
extern const char wuffs_webp__error__bad_header[];
|
||||
extern const char wuffs_webp__error__bad_transform[];
|
||||
extern const char wuffs_webp__error__short_chunk[];
|
||||
extern const char wuffs_webp__error__truncated_input[];
|
||||
extern const char wuffs_webp__error__unsupported_number_of_huffman_groups[];
|
||||
extern const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[];
|
||||
extern const char wuffs_webp__error__unsupported_webp_file[];
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
@@ -13915,15 +13926,117 @@ struct wuffs_webp__decoder__struct {
|
||||
uint32_t f_width;
|
||||
uint32_t f_height;
|
||||
uint8_t f_call_sequence;
|
||||
uint8_t f_code_length_code_lengths[19];
|
||||
bool f_sub_chunk_has_padding;
|
||||
uint64_t f_frame_config_io_position;
|
||||
uint32_t f_riff_chunk_length;
|
||||
uint32_t f_sub_chunk_length;
|
||||
uint32_t f_bits;
|
||||
uint32_t f_n_bits;
|
||||
bool f_seen_transform[4];
|
||||
uint8_t f_transform_type[4];
|
||||
uint8_t f_transform_tile_size_log2[4];
|
||||
uint32_t f_n_transforms;
|
||||
uint32_t f_color_cache_bits;
|
||||
uint32_t f_overall_color_cache_bits;
|
||||
uint32_t f_overall_tile_size_log2;
|
||||
uint32_t f_overall_n_huffman_groups;
|
||||
uint32_t f_ht_n_symbols;
|
||||
uint32_t f_ht_code_lengths_remaining;
|
||||
uint32_t f_color_indexing_palette_size;
|
||||
uint32_t f_color_indexing_width;
|
||||
uint32_t f_workbuf_offset_for_transform[4];
|
||||
uint32_t f_workbuf_offset_for_color_indexing;
|
||||
wuffs_base__pixel_swizzler f_swizzler;
|
||||
|
||||
uint32_t p_decode_huffman_groups;
|
||||
uint32_t p_decode_huffman_tree;
|
||||
uint32_t p_decode_huffman_tree_simple;
|
||||
uint32_t p_decode_code_length_code_lengths;
|
||||
uint32_t p_build_code_lengths;
|
||||
uint32_t p_decode_pixels_slow;
|
||||
uint32_t p_decode_image_config;
|
||||
uint32_t p_do_decode_image_config;
|
||||
uint32_t p_do_decode_image_config_limited;
|
||||
uint32_t p_do_decode_image_config_limited_vp8l;
|
||||
uint32_t p_decode_frame_config;
|
||||
uint32_t p_do_decode_frame_config;
|
||||
uint32_t p_decode_frame;
|
||||
uint32_t p_do_decode_frame;
|
||||
uint32_t p_decode_transform;
|
||||
uint32_t p_decode_color_cache_parameters;
|
||||
uint32_t p_decode_hg_table;
|
||||
uint32_t p_decode_pixels;
|
||||
} private_impl;
|
||||
|
||||
struct {
|
||||
uint8_t f_palette[1024];
|
||||
uint32_t f_color_cache[2048];
|
||||
uint16_t f_codes[2328];
|
||||
uint16_t f_code_lengths[2328];
|
||||
uint16_t f_code_lengths_huffman_nodes[37];
|
||||
uint16_t f_huffman_nodes[256][6267];
|
||||
|
||||
struct {
|
||||
uint32_t v_hg;
|
||||
uint32_t v_ht;
|
||||
} s_decode_huffman_groups;
|
||||
struct {
|
||||
uint32_t v_use_second_symbol;
|
||||
uint32_t v_first_symbol_n_bits;
|
||||
uint32_t v_symbol0;
|
||||
uint32_t v_base_offset;
|
||||
} s_decode_huffman_tree_simple;
|
||||
struct {
|
||||
uint32_t v_n_codes;
|
||||
uint32_t v_i;
|
||||
} s_decode_code_length_code_lengths;
|
||||
struct {
|
||||
uint32_t v_length_n_bits;
|
||||
uint16_t v_prev_code_length;
|
||||
uint32_t v_s;
|
||||
uint32_t v_s_max;
|
||||
uint16_t v_node;
|
||||
uint16_t v_repeat_value;
|
||||
uint32_t v_repeat_n_bits;
|
||||
} s_build_code_lengths;
|
||||
struct {
|
||||
uint64_t v_p;
|
||||
uint64_t v_p_max;
|
||||
uint32_t v_tile_size_log2;
|
||||
uint32_t v_width_in_tiles;
|
||||
uint32_t v_x;
|
||||
uint32_t v_y;
|
||||
uint32_t v_hg;
|
||||
uint16_t v_node;
|
||||
uint32_t v_color;
|
||||
uint32_t v_back_ref_len_n_bits;
|
||||
uint32_t v_back_ref_len_minus_1;
|
||||
uint32_t v_back_ref_dist_n_bits;
|
||||
uint32_t v_back_ref_dist_premap_minus_1;
|
||||
uint64_t v_color_cache_p;
|
||||
} s_decode_pixels_slow;
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config;
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config_limited;
|
||||
struct {
|
||||
uint64_t scratch;
|
||||
} s_do_decode_image_config_limited_vp8l;
|
||||
struct {
|
||||
uint32_t v_width;
|
||||
} s_do_decode_frame;
|
||||
struct {
|
||||
uint32_t v_transform_type;
|
||||
uint32_t v_tile_size_log2;
|
||||
} s_decode_transform;
|
||||
struct {
|
||||
uint32_t v_tile_size_log2;
|
||||
} s_decode_hg_table;
|
||||
} private_data;
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_webp__decoder, wuffs_unique_ptr_deleter>;
|
||||
@@ -69161,14 +69274,212 @@ wuffs_wbmp__decoder__workbuf_len(
|
||||
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
const char wuffs_webp__error__bad_huffman_code_over_subscribed[] = "#webp: bad Huffman code (over-subscribed)";
|
||||
const char wuffs_webp__error__bad_huffman_code_under_subscribed[] = "#webp: bad Huffman code (under-subscribed)";
|
||||
const char wuffs_webp__error__bad_huffman_code[] = "#webp: bad Huffman code";
|
||||
const char wuffs_webp__error__bad_back_reference[] = "#webp: bad back-reference";
|
||||
const char wuffs_webp__error__bad_color_cache[] = "#webp: bad color cache";
|
||||
const char wuffs_webp__error__bad_header[] = "#webp: bad header";
|
||||
const char wuffs_webp__error__bad_transform[] = "#webp: bad transform";
|
||||
const char wuffs_webp__error__short_chunk[] = "#webp: short chunk";
|
||||
const char wuffs_webp__error__truncated_input[] = "#webp: truncated input";
|
||||
const char wuffs_webp__error__unsupported_number_of_huffman_groups[] = "#webp: unsupported number of Huffman groups";
|
||||
const char wuffs_webp__error__unsupported_transform_after_color_indexing_transform[] = "#webp: unsupported transform after color indexing transform";
|
||||
const char wuffs_webp__error__unsupported_webp_file[] = "#webp: unsupported WebP file";
|
||||
const char wuffs_webp__error__internal_error_inconsistent_huffman_code[] = "#webp: internal error: inconsistent Huffman code";
|
||||
const char wuffs_webp__error__internal_error_inconsistent_dst_buffer[] = "#webp: internal error: inconsistent dst buffer";
|
||||
const char wuffs_webp__error__internal_error_inconsistent_n_bits[] = "#webp: internal error: inconsistent n_bits";
|
||||
|
||||
// ---------------- Private Consts
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[19] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
17u, 18u, 0u, 1u, 2u, 3u, 4u, 5u,
|
||||
16u, 6u, 7u, 8u, 9u, 10u, 11u, 12u,
|
||||
13u, 14u, 15u,
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_WEBP__REPEAT_N_BITS[4] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
2u, 3u, 7u, 0u,
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_WEBP__REPEAT_COUNTS[4] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
3u, 3u, 11u, 0u,
|
||||
};
|
||||
|
||||
static const uint16_t
|
||||
WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[5] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
1612u, 0u, 511u, 1022u, 1533u,
|
||||
};
|
||||
|
||||
static const uint32_t
|
||||
WUFFS_WEBP__SIGN_EXTEND_I8_I32[256] 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,
|
||||
4294967168u, 4294967169u, 4294967170u, 4294967171u, 4294967172u, 4294967173u, 4294967174u, 4294967175u,
|
||||
4294967176u, 4294967177u, 4294967178u, 4294967179u, 4294967180u, 4294967181u, 4294967182u, 4294967183u,
|
||||
4294967184u, 4294967185u, 4294967186u, 4294967187u, 4294967188u, 4294967189u, 4294967190u, 4294967191u,
|
||||
4294967192u, 4294967193u, 4294967194u, 4294967195u, 4294967196u, 4294967197u, 4294967198u, 4294967199u,
|
||||
4294967200u, 4294967201u, 4294967202u, 4294967203u, 4294967204u, 4294967205u, 4294967206u, 4294967207u,
|
||||
4294967208u, 4294967209u, 4294967210u, 4294967211u, 4294967212u, 4294967213u, 4294967214u, 4294967215u,
|
||||
4294967216u, 4294967217u, 4294967218u, 4294967219u, 4294967220u, 4294967221u, 4294967222u, 4294967223u,
|
||||
4294967224u, 4294967225u, 4294967226u, 4294967227u, 4294967228u, 4294967229u, 4294967230u, 4294967231u,
|
||||
4294967232u, 4294967233u, 4294967234u, 4294967235u, 4294967236u, 4294967237u, 4294967238u, 4294967239u,
|
||||
4294967240u, 4294967241u, 4294967242u, 4294967243u, 4294967244u, 4294967245u, 4294967246u, 4294967247u,
|
||||
4294967248u, 4294967249u, 4294967250u, 4294967251u, 4294967252u, 4294967253u, 4294967254u, 4294967255u,
|
||||
4294967256u, 4294967257u, 4294967258u, 4294967259u, 4294967260u, 4294967261u, 4294967262u, 4294967263u,
|
||||
4294967264u, 4294967265u, 4294967266u, 4294967267u, 4294967268u, 4294967269u, 4294967270u, 4294967271u,
|
||||
4294967272u, 4294967273u, 4294967274u, 4294967275u, 4294967276u, 4294967277u, 4294967278u, 4294967279u,
|
||||
4294967280u, 4294967281u, 4294967282u, 4294967283u, 4294967284u, 4294967285u, 4294967286u, 4294967287u,
|
||||
4294967288u, 4294967289u, 4294967290u, 4294967291u, 4294967292u, 4294967293u, 4294967294u, 4294967295u,
|
||||
};
|
||||
|
||||
static const uint8_t
|
||||
WUFFS_WEBP__DISTANCE_MAP[120] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
24u, 7u, 23u, 25u, 40u, 6u, 39u, 41u,
|
||||
22u, 26u, 38u, 42u, 56u, 5u, 55u, 57u,
|
||||
21u, 27u, 54u, 58u, 37u, 43u, 72u, 4u,
|
||||
71u, 73u, 20u, 28u, 53u, 59u, 70u, 74u,
|
||||
36u, 44u, 88u, 69u, 75u, 52u, 60u, 3u,
|
||||
87u, 89u, 19u, 29u, 86u, 90u, 35u, 45u,
|
||||
68u, 76u, 85u, 91u, 51u, 61u, 104u, 2u,
|
||||
103u, 105u, 18u, 30u, 102u, 106u, 34u, 46u,
|
||||
84u, 92u, 67u, 77u, 101u, 107u, 50u, 62u,
|
||||
120u, 1u, 119u, 121u, 83u, 93u, 17u, 31u,
|
||||
100u, 108u, 66u, 78u, 118u, 122u, 33u, 47u,
|
||||
117u, 123u, 49u, 63u, 99u, 109u, 82u, 94u,
|
||||
0u, 116u, 124u, 65u, 79u, 16u, 32u, 98u,
|
||||
110u, 48u, 115u, 125u, 81u, 95u, 64u, 114u,
|
||||
126u, 97u, 111u, 80u, 113u, 127u, 96u, 112u,
|
||||
};
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_groups(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_n_huffman_groups);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_tree(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_hg,
|
||||
uint32_t a_ht);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_tree_simple(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_hg,
|
||||
uint32_t a_ht);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_code_length_code_lengths(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__build_code_lengths_huffman_nodes(
|
||||
wuffs_webp__decoder* self);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__build_huffman_nodes(
|
||||
wuffs_webp__decoder* self,
|
||||
uint32_t a_hg,
|
||||
uint32_t a_ht);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__build_code_lengths(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_pixels_slow(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_width,
|
||||
uint32_t a_height,
|
||||
wuffs_base__slice_u8 a_tile_data,
|
||||
uint32_t a_tile_size_log2);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_predictor(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
wuffs_base__slice_u8 a_tile_data);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_webp__decoder__absolute_difference(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint32_t a_a,
|
||||
uint32_t a_b);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint8_t
|
||||
wuffs_webp__decoder__mode12(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint8_t a_l,
|
||||
uint8_t a_t,
|
||||
uint8_t a_tl);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint8_t
|
||||
wuffs_webp__decoder__mode13(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint8_t a_l,
|
||||
uint8_t a_t,
|
||||
uint8_t a_tl);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_cross_color(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
wuffs_base__slice_u8 a_tile_data);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_subtract_green(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config(
|
||||
@@ -69176,6 +69487,18 @@ wuffs_webp__decoder__do_decode_image_config(
|
||||
wuffs_base__image_config* a_dst,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_frame_config(
|
||||
@@ -69193,6 +69516,46 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
wuffs_base__slice_u8 a_workbuf,
|
||||
wuffs_base__decode_frame_options* a_opts);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_transform(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_color_cache_parameters(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_hg_table(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_width,
|
||||
wuffs_base__slice_u8 a_workbuf);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_pixels(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_width,
|
||||
uint32_t a_height,
|
||||
wuffs_base__slice_u8 a_tile_data,
|
||||
uint32_t a_tile_size_log2);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__swizzle(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__slice_u8 a_src,
|
||||
wuffs_base__pixel_blend a_blend);
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
const wuffs_base__image_decoder__func_ptrs
|
||||
@@ -69302,6 +69665,2089 @@ sizeof__wuffs_webp__decoder(void) {
|
||||
|
||||
// ---------------- Function Implementations
|
||||
|
||||
// -------- func webp.decoder.decode_huffman_groups
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_groups(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_n_huffman_groups) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_hg = 0;
|
||||
uint32_t v_ht = 0;
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_groups;
|
||||
if (coro_susp_point) {
|
||||
v_hg = self->private_data.s_decode_huffman_groups.v_hg;
|
||||
v_ht = self->private_data.s_decode_huffman_groups.v_ht;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_hg = 0u;
|
||||
while (v_hg < a_n_huffman_groups) {
|
||||
v_ht = 0u;
|
||||
while (v_ht < 5u) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__decode_huffman_tree(self, a_src, v_hg, v_ht);
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
v_ht += 1u;
|
||||
}
|
||||
v_hg += 1u;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_huffman_groups = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_huffman_groups = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_huffman_groups.v_hg = v_hg;
|
||||
self->private_data.s_decode_huffman_groups.v_ht = v_ht;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_huffman_tree
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_tree(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_hg,
|
||||
uint32_t a_ht) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c8 = 0;
|
||||
uint32_t v_use_simple = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (a_ht >= 4u) {
|
||||
self->private_impl.f_ht_n_symbols = 40u;
|
||||
} else if (a_ht > 0u) {
|
||||
self->private_impl.f_ht_n_symbols = 256u;
|
||||
} else if (self->private_impl.f_color_cache_bits == 0u) {
|
||||
self->private_impl.f_ht_n_symbols = 280u;
|
||||
} else {
|
||||
self->private_impl.f_ht_n_symbols = (280u + (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits));
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_use_simple = (self->private_impl.f_bits & 1u);
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
if (v_use_simple != 0u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
status = wuffs_webp__decoder__decode_huffman_tree_simple(self, a_src, a_hg, a_ht);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_webp__decoder__decode_code_length_code_lengths(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
v_status = wuffs_webp__decoder__build_code_lengths_huffman_nodes(self);
|
||||
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;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_webp__decoder__build_code_lengths(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
v_status = wuffs_webp__decoder__build_huffman_nodes(self, a_hg, a_ht);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_huffman_tree = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_huffman_tree = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_huffman_tree_simple
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_huffman_tree_simple(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_hg,
|
||||
uint32_t a_ht) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c8 = 0;
|
||||
uint32_t v_use_second_symbol = 0;
|
||||
uint32_t v_first_symbol_n_bits = 0;
|
||||
uint32_t v_symbol0 = 0;
|
||||
uint32_t v_symbol1 = 0;
|
||||
uint32_t v_base_offset = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_huffman_tree_simple;
|
||||
if (coro_susp_point) {
|
||||
v_use_second_symbol = self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol;
|
||||
v_first_symbol_n_bits = self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits;
|
||||
v_symbol0 = self->private_data.s_decode_huffman_tree_simple.v_symbol0;
|
||||
v_base_offset = self->private_data.s_decode_huffman_tree_simple.v_base_offset;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_n_bits < 2u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 2u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_use_second_symbol = (self->private_impl.f_bits & 1u);
|
||||
v_first_symbol_n_bits = ((((self->private_impl.f_bits & 2u) >> 1u) * 7u) + 1u);
|
||||
self->private_impl.f_bits >>= 2u;
|
||||
self->private_impl.f_n_bits -= 2u;
|
||||
if (self->private_impl.f_n_bits < v_first_symbol_n_bits) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= v_first_symbol_n_bits) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_symbol0 = (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_first_symbol_n_bits) - 1u));
|
||||
self->private_impl.f_bits >>= v_first_symbol_n_bits;
|
||||
self->private_impl.f_n_bits -= v_first_symbol_n_bits;
|
||||
v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht]));
|
||||
if (v_use_second_symbol != 0u) {
|
||||
if (self->private_impl.f_n_bits < 8u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 8u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_symbol1 = (self->private_impl.f_bits & 255u);
|
||||
self->private_impl.f_bits >>= 8u;
|
||||
self->private_impl.f_n_bits -= 8u;
|
||||
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 0u)] = ((uint16_t)((v_base_offset + 1u)));
|
||||
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 1u)] = ((uint16_t)((v_symbol0 | 32768u)));
|
||||
self->private_data.f_huffman_nodes[a_hg][(v_base_offset + 2u)] = ((uint16_t)((v_symbol1 | 32768u)));
|
||||
} else {
|
||||
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_symbol0 | 32768u)));
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_huffman_tree_simple = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_huffman_tree_simple = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_huffman_tree_simple.v_use_second_symbol = v_use_second_symbol;
|
||||
self->private_data.s_decode_huffman_tree_simple.v_first_symbol_n_bits = v_first_symbol_n_bits;
|
||||
self->private_data.s_decode_huffman_tree_simple.v_symbol0 = v_symbol0;
|
||||
self->private_data.s_decode_huffman_tree_simple.v_base_offset = v_base_offset;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_code_length_code_lengths
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_code_length_code_lengths(
|
||||
wuffs_webp__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_n_codes = 0;
|
||||
uint32_t v_i = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_code_length_code_lengths;
|
||||
if (coro_susp_point) {
|
||||
v_n_codes = self->private_data.s_decode_code_length_code_lengths.v_n_codes;
|
||||
v_i = self->private_data.s_decode_code_length_code_lengths.v_i;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_n_bits < 4u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 4u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_n_codes = ((self->private_impl.f_bits & 15u) + 4u);
|
||||
self->private_impl.f_bits >>= 4u;
|
||||
self->private_impl.f_n_bits -= 4u;
|
||||
v_i = 0u;
|
||||
while (v_i < v_n_codes) {
|
||||
if (self->private_impl.f_n_bits < 3u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 3u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = ((uint8_t)((self->private_impl.f_bits & 7u)));
|
||||
self->private_impl.f_bits >>= 3u;
|
||||
self->private_impl.f_n_bits -= 3u;
|
||||
v_i += 1u;
|
||||
}
|
||||
while (v_i < 19u) {
|
||||
self->private_impl.f_code_length_code_lengths[WUFFS_WEBP__CODE_LENGTH_CODE_ORDER[v_i]] = 0u;
|
||||
v_i += 1u;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_code_length_code_lengths = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_code_length_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_code_length_code_lengths.v_n_codes = v_n_codes;
|
||||
self->private_data.s_decode_code_length_code_lengths.v_i = v_i;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.build_code_lengths_huffman_nodes
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__build_code_lengths_huffman_nodes(
|
||||
wuffs_webp__decoder* self) {
|
||||
uint32_t v_code_bits = 0;
|
||||
uint32_t v_code_len = 0;
|
||||
uint32_t v_symbol = 0;
|
||||
uint32_t v_histogram[8] = {0};
|
||||
uint32_t v_n_used_symbols = 0;
|
||||
uint32_t v_last_used_symbol = 0;
|
||||
uint32_t v_subscription_weight = 0;
|
||||
uint32_t v_subscription_total = 0;
|
||||
uint32_t v_curr_code = 0;
|
||||
uint32_t v_next_codes[9] = {0};
|
||||
uint32_t v_n_branches = 0;
|
||||
uint32_t v_h = 0;
|
||||
uint32_t v_children = 0;
|
||||
uint16_t v_node = 0;
|
||||
|
||||
v_symbol = 0u;
|
||||
while (v_symbol < 19u) {
|
||||
v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol]));
|
||||
if (v_code_len != 0u) {
|
||||
v_histogram[v_code_len] += 1u;
|
||||
v_n_used_symbols += 1u;
|
||||
v_last_used_symbol = v_symbol;
|
||||
}
|
||||
v_symbol += 1u;
|
||||
}
|
||||
if (v_n_used_symbols < 1u) {
|
||||
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
|
||||
} else if (v_n_used_symbols == 1u) {
|
||||
self->private_data.f_code_lengths_huffman_nodes[0u] = ((uint16_t)((v_last_used_symbol | 32768u)));
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
v_subscription_weight = 16384u;
|
||||
v_code_len = 1u;
|
||||
while (true) {
|
||||
v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u));
|
||||
v_next_codes[(v_code_len + 1u)] = v_curr_code;
|
||||
v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len]));
|
||||
v_subscription_weight >>= 1u;
|
||||
if (v_code_len >= 7u) {
|
||||
break;
|
||||
}
|
||||
v_code_len += 1u;
|
||||
}
|
||||
if (v_subscription_total > 32768u) {
|
||||
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed);
|
||||
} else if (v_subscription_total < 32768u) {
|
||||
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed);
|
||||
}
|
||||
self->private_data.f_code_lengths_huffman_nodes[0u] = 0u;
|
||||
v_symbol = 0u;
|
||||
while (v_symbol < 19u) {
|
||||
v_code_len = ((uint32_t)(self->private_impl.f_code_length_code_lengths[v_symbol]));
|
||||
if (v_code_len > 0u) {
|
||||
v_code_bits = v_next_codes[v_code_len];
|
||||
v_next_codes[v_code_len] += 1u;
|
||||
v_code_bits <<= (32u - v_code_len);
|
||||
v_h = 0u;
|
||||
while (v_code_len > 0u) {
|
||||
v_node = self->private_data.f_code_lengths_huffman_nodes[v_h];
|
||||
if (v_node == 0u) {
|
||||
v_children = ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches))));
|
||||
v_children = wuffs_base__u32__min(v_children, 35u);
|
||||
self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)(v_children));
|
||||
self->private_data.f_code_lengths_huffman_nodes[(v_children + 0u)] = 0u;
|
||||
self->private_data.f_code_lengths_huffman_nodes[(v_children + 1u)] = 0u;
|
||||
v_h = (v_children + (v_code_bits >> 31u));
|
||||
v_n_branches += 1u;
|
||||
} else {
|
||||
v_children = ((uint32_t)(v_node));
|
||||
v_h = (wuffs_base__u32__min(v_children, 35u) + (v_code_bits >> 31u));
|
||||
}
|
||||
v_code_bits <<= 1u;
|
||||
v_code_len -= 1u;
|
||||
}
|
||||
self->private_data.f_code_lengths_huffman_nodes[v_h] = ((uint16_t)((v_symbol | 32768u)));
|
||||
}
|
||||
v_symbol += 1u;
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.build_huffman_nodes
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__build_huffman_nodes(
|
||||
wuffs_webp__decoder* self,
|
||||
uint32_t a_hg,
|
||||
uint32_t a_ht) {
|
||||
uint32_t v_base_offset = 0;
|
||||
uint32_t v_code_bits = 0;
|
||||
uint32_t v_code_len = 0;
|
||||
uint32_t v_symbol = 0;
|
||||
uint32_t v_histogram[16] = {0};
|
||||
uint32_t v_n_used_symbols = 0;
|
||||
uint32_t v_last_used_symbol = 0;
|
||||
uint32_t v_subscription_weight = 0;
|
||||
uint32_t v_subscription_total = 0;
|
||||
uint32_t v_curr_code = 0;
|
||||
uint32_t v_next_codes[17] = {0};
|
||||
uint32_t v_n_branches = 0;
|
||||
uint32_t v_h = 0;
|
||||
uint32_t v_children = 0;
|
||||
uint16_t v_node = 0;
|
||||
|
||||
v_base_offset = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[a_ht]));
|
||||
v_symbol = 0u;
|
||||
while (v_symbol < self->private_impl.f_ht_n_symbols) {
|
||||
v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u))));
|
||||
if (v_code_len != 0u) {
|
||||
v_histogram[v_code_len] += 1u;
|
||||
v_n_used_symbols += 1u;
|
||||
v_last_used_symbol = v_symbol;
|
||||
}
|
||||
v_symbol += 1u;
|
||||
}
|
||||
if (v_n_used_symbols < 1u) {
|
||||
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
|
||||
} else if (v_n_used_symbols == 1u) {
|
||||
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = ((uint16_t)((v_last_used_symbol | 32768u)));
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
v_subscription_weight = 16384u;
|
||||
v_code_len = 1u;
|
||||
while (true) {
|
||||
v_curr_code = ((uint32_t)(((uint32_t)(v_curr_code + v_histogram[v_code_len])) << 1u));
|
||||
v_next_codes[(v_code_len + 1u)] = v_curr_code;
|
||||
v_subscription_total += ((uint32_t)(v_subscription_weight * v_histogram[v_code_len]));
|
||||
v_subscription_weight >>= 1u;
|
||||
if (v_code_len >= 15u) {
|
||||
break;
|
||||
}
|
||||
v_code_len += 1u;
|
||||
}
|
||||
if (v_subscription_total > 32768u) {
|
||||
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_over_subscribed);
|
||||
} else if (v_subscription_total < 32768u) {
|
||||
return wuffs_base__make_status(wuffs_webp__error__bad_huffman_code_under_subscribed);
|
||||
}
|
||||
self->private_data.f_huffman_nodes[a_hg][v_base_offset] = 0u;
|
||||
v_symbol = 0u;
|
||||
while (v_symbol < self->private_impl.f_ht_n_symbols) {
|
||||
v_code_len = ((uint32_t)(((uint16_t)(self->private_data.f_code_lengths[v_symbol] & 15u))));
|
||||
if (v_code_len != 0u) {
|
||||
v_code_bits = v_next_codes[v_code_len];
|
||||
v_next_codes[v_code_len] += 1u;
|
||||
v_code_bits <<= (32u - v_code_len);
|
||||
v_h = v_base_offset;
|
||||
while (v_code_len > 0u) {
|
||||
v_node = self->private_data.f_huffman_nodes[a_hg][v_h];
|
||||
if (v_node == 0u) {
|
||||
v_children = ((uint32_t)(v_base_offset + ((uint32_t)(1u + ((uint32_t)(2u * v_n_branches))))));
|
||||
v_children = wuffs_base__u32__min(v_children, 6265u);
|
||||
self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)(v_children));
|
||||
self->private_data.f_huffman_nodes[a_hg][(v_children + 0u)] = 0u;
|
||||
self->private_data.f_huffman_nodes[a_hg][(v_children + 1u)] = 0u;
|
||||
v_h = (v_children + (v_code_bits >> 31u));
|
||||
v_n_branches += 1u;
|
||||
} else {
|
||||
v_children = ((uint32_t)(v_node));
|
||||
v_h = (wuffs_base__u32__min(v_children, 6265u) + (v_code_bits >> 31u));
|
||||
}
|
||||
v_code_bits <<= 1u;
|
||||
v_code_len -= 1u;
|
||||
}
|
||||
self->private_data.f_huffman_nodes[a_hg][v_h] = ((uint16_t)((v_symbol | 32768u)));
|
||||
}
|
||||
v_symbol += 1u;
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.build_code_lengths
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__build_code_lengths(
|
||||
wuffs_webp__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_use_length = 0;
|
||||
uint32_t v_length_n_bits = 0;
|
||||
uint32_t v_length = 0;
|
||||
uint16_t v_prev_code_length = 0;
|
||||
uint32_t v_h = 0;
|
||||
uint32_t v_s = 0;
|
||||
uint32_t v_s_max = 0;
|
||||
uint16_t v_node = 0;
|
||||
uint32_t v_symbol = 0;
|
||||
uint16_t v_repeat_value = 0;
|
||||
uint32_t v_repeat_n_bits = 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_build_code_lengths;
|
||||
if (coro_susp_point) {
|
||||
v_length_n_bits = self->private_data.s_build_code_lengths.v_length_n_bits;
|
||||
v_prev_code_length = self->private_data.s_build_code_lengths.v_prev_code_length;
|
||||
v_s = self->private_data.s_build_code_lengths.v_s;
|
||||
v_s_max = self->private_data.s_build_code_lengths.v_s_max;
|
||||
v_node = self->private_data.s_build_code_lengths.v_node;
|
||||
v_repeat_value = self->private_data.s_build_code_lengths.v_repeat_value;
|
||||
v_repeat_n_bits = self->private_data.s_build_code_lengths.v_repeat_n_bits;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_use_length = (self->private_impl.f_bits & 1u);
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
self->private_impl.f_ht_code_lengths_remaining = self->private_impl.f_ht_n_symbols;
|
||||
if (v_use_length != 0u) {
|
||||
if (self->private_impl.f_n_bits < 3u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 3u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_length_n_bits = (((self->private_impl.f_bits & 7u) * 2u) + 2u);
|
||||
self->private_impl.f_bits >>= 3u;
|
||||
self->private_impl.f_n_bits -= 3u;
|
||||
while (self->private_impl.f_n_bits < v_length_n_bits) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= v_length_n_bits) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_length = ((self->private_impl.f_bits & ((((uint32_t)(1u)) << v_length_n_bits) - 1u)) + 2u);
|
||||
self->private_impl.f_bits >>= v_length_n_bits;
|
||||
self->private_impl.f_n_bits -= v_length_n_bits;
|
||||
if (v_length > self->private_impl.f_ht_n_symbols) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_ht_code_lengths_remaining = v_length;
|
||||
}
|
||||
v_prev_code_length = 8u;
|
||||
while (v_s < self->private_impl.f_ht_n_symbols) {
|
||||
if (self->private_impl.f_ht_code_lengths_remaining <= 0u) {
|
||||
while (v_s < self->private_impl.f_ht_n_symbols) {
|
||||
self->private_data.f_code_lengths[v_s] = 0u;
|
||||
v_s += 1u;
|
||||
}
|
||||
break;
|
||||
}
|
||||
self->private_impl.f_ht_code_lengths_remaining -= 1u;
|
||||
v_h = 0u;
|
||||
while (true) {
|
||||
v_node = self->private_data.f_code_lengths_huffman_nodes[v_h];
|
||||
if (v_node >= 32768u) {
|
||||
break;
|
||||
} else if (v_node > 35u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u));
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
}
|
||||
v_symbol = ((uint32_t)(((uint16_t)(v_node & 32767u))));
|
||||
if (v_symbol == 0u) {
|
||||
self->private_data.f_code_lengths[v_s] = 0u;
|
||||
v_s += 1u;
|
||||
continue;
|
||||
} else if (v_symbol < 16u) {
|
||||
v_prev_code_length = ((uint16_t)(v_symbol));
|
||||
self->private_data.f_code_lengths[v_s] = v_prev_code_length;
|
||||
v_s += 1u;
|
||||
continue;
|
||||
} else if (v_symbol == 16u) {
|
||||
v_repeat_value = v_prev_code_length;
|
||||
} else {
|
||||
v_repeat_value = 0u;
|
||||
}
|
||||
v_repeat_n_bits = ((uint32_t)(WUFFS_WEBP__REPEAT_N_BITS[(v_symbol & 3u)]));
|
||||
v_s_max = ((uint32_t)(((uint32_t)(WUFFS_WEBP__REPEAT_COUNTS[(v_symbol & 3u)])) + v_s));
|
||||
if (self->private_impl.f_n_bits < v_repeat_n_bits) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
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_4 = *iop_a_src++;
|
||||
v_c8 = t_4;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= v_repeat_n_bits) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_s_max += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_repeat_n_bits) - 1u));
|
||||
self->private_impl.f_bits >>= v_repeat_n_bits;
|
||||
self->private_impl.f_n_bits -= v_repeat_n_bits;
|
||||
if (v_s_max > self->private_impl.f_ht_n_symbols) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_huffman_code);
|
||||
goto exit;
|
||||
}
|
||||
while (v_s < v_s_max) {
|
||||
self->private_data.f_code_lengths[v_s] = v_repeat_value;
|
||||
v_s += 1u;
|
||||
}
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_build_code_lengths = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_build_code_lengths = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_build_code_lengths.v_length_n_bits = v_length_n_bits;
|
||||
self->private_data.s_build_code_lengths.v_prev_code_length = v_prev_code_length;
|
||||
self->private_data.s_build_code_lengths.v_s = v_s;
|
||||
self->private_data.s_build_code_lengths.v_s_max = v_s_max;
|
||||
self->private_data.s_build_code_lengths.v_node = v_node;
|
||||
self->private_data.s_build_code_lengths.v_repeat_value = v_repeat_value;
|
||||
self->private_data.s_build_code_lengths.v_repeat_n_bits = v_repeat_n_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 webp.decoder.decode_pixels_slow
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_pixels_slow(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_width,
|
||||
uint32_t a_height,
|
||||
wuffs_base__slice_u8 a_tile_data,
|
||||
uint32_t a_tile_size_log2) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c8 = 0;
|
||||
uint64_t v_p = 0;
|
||||
uint64_t v_p_max = 0;
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_width_in_tiles = 0;
|
||||
uint32_t v_x = 0;
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_i = 0;
|
||||
uint32_t v_hg = 0;
|
||||
uint32_t v_h = 0;
|
||||
uint16_t v_node = 0;
|
||||
uint32_t v_pixel_g = 0;
|
||||
uint32_t v_color = 0;
|
||||
wuffs_base__slice_u8 v_dst_pixel = {0};
|
||||
uint32_t v_back_ref_len_n_bits = 0;
|
||||
uint32_t v_back_ref_len_minus_1 = 0;
|
||||
uint32_t v_back_ref_dist_n_bits = 0;
|
||||
uint32_t v_back_ref_dist_sym = 0;
|
||||
uint32_t v_back_ref_dist_premap_minus_1 = 0;
|
||||
uint32_t v_back_ref_dist_minus_1 = 0;
|
||||
uint32_t v_dm = 0;
|
||||
uint32_t v_dx = 0;
|
||||
uint32_t v_dy = 0;
|
||||
uint64_t v_p_end = 0;
|
||||
uint64_t v_dist4 = 0;
|
||||
uint64_t v_q = 0;
|
||||
wuffs_base__slice_u8 v_color_cache_pixels = {0};
|
||||
uint64_t v_color_cache_p = 0;
|
||||
uint32_t v_color_cache_shift = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_pixels_slow;
|
||||
if (coro_susp_point) {
|
||||
v_p = self->private_data.s_decode_pixels_slow.v_p;
|
||||
v_p_max = self->private_data.s_decode_pixels_slow.v_p_max;
|
||||
v_tile_size_log2 = self->private_data.s_decode_pixels_slow.v_tile_size_log2;
|
||||
v_width_in_tiles = self->private_data.s_decode_pixels_slow.v_width_in_tiles;
|
||||
v_x = self->private_data.s_decode_pixels_slow.v_x;
|
||||
v_y = self->private_data.s_decode_pixels_slow.v_y;
|
||||
v_hg = self->private_data.s_decode_pixels_slow.v_hg;
|
||||
v_node = self->private_data.s_decode_pixels_slow.v_node;
|
||||
v_color = self->private_data.s_decode_pixels_slow.v_color;
|
||||
v_back_ref_len_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits;
|
||||
v_back_ref_len_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1;
|
||||
v_back_ref_dist_n_bits = self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits;
|
||||
v_back_ref_dist_premap_minus_1 = self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1;
|
||||
v_color_cache_p = self->private_data.s_decode_pixels_slow.v_color_cache_p;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_p_max = ((uint64_t)((4u * a_width * a_height)));
|
||||
if (((uint64_t)(a_dst.len)) < v_p_max) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
|
||||
goto exit;
|
||||
}
|
||||
if (a_tile_size_log2 != 0u) {
|
||||
v_tile_size_log2 = a_tile_size_log2;
|
||||
v_width_in_tiles = ((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
} else {
|
||||
v_tile_size_log2 = 31u;
|
||||
v_width_in_tiles = 1u;
|
||||
}
|
||||
while (v_p < v_p_max) {
|
||||
v_i = ((uint32_t)(((uint32_t)(((uint32_t)(((uint32_t)((v_y >> v_tile_size_log2) * v_width_in_tiles)) + (v_x >> v_tile_size_log2))) * 4u)) + 1u));
|
||||
if (((uint64_t)(v_i)) < ((uint64_t)(a_tile_data.len))) {
|
||||
v_hg = ((uint32_t)(a_tile_data.ptr[((uint64_t)(v_i))]));
|
||||
}
|
||||
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[0u]));
|
||||
while (true) {
|
||||
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
|
||||
if (v_node >= 32768u) {
|
||||
break;
|
||||
} else if (v_node > 6265u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_huffman_code);
|
||||
goto exit;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_h = (((uint32_t)(v_node)) + (self->private_impl.f_bits & 1u));
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
}
|
||||
v_pixel_g = ((uint32_t)(((uint16_t)(v_node & 32767u))));
|
||||
if (v_pixel_g < 256u) {
|
||||
v_color = (v_pixel_g << 8u);
|
||||
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[1u]));
|
||||
while (true) {
|
||||
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
|
||||
if (v_node >= 32768u) {
|
||||
break;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
}
|
||||
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 16u);
|
||||
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[2u]));
|
||||
while (true) {
|
||||
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
|
||||
if (v_node >= 32768u) {
|
||||
break;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
}
|
||||
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 0u);
|
||||
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[3u]));
|
||||
while (true) {
|
||||
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
|
||||
if (v_node >= 32768u) {
|
||||
break;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
}
|
||||
v_color |= (((uint32_t)(((uint16_t)(v_node & 255u)))) << 24u);
|
||||
} else if (v_pixel_g < 280u) {
|
||||
if (v_pixel_g < 260u) {
|
||||
v_back_ref_len_minus_1 = (v_pixel_g - 256u);
|
||||
} else {
|
||||
v_back_ref_len_n_bits = ((v_pixel_g - 258u) >> 1u);
|
||||
v_back_ref_len_minus_1 = ((((uint32_t)(2u)) + (v_pixel_g & 1u)) << v_back_ref_len_n_bits);
|
||||
while (self->private_impl.f_n_bits < v_back_ref_len_n_bits) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
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_4 = *iop_a_src++;
|
||||
v_c8 = t_4;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= v_back_ref_len_n_bits) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_back_ref_len_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_len_n_bits) - 1u));
|
||||
self->private_impl.f_bits >>= v_back_ref_len_n_bits;
|
||||
self->private_impl.f_n_bits -= v_back_ref_len_n_bits;
|
||||
}
|
||||
v_h = ((uint32_t)(WUFFS_WEBP__HUFFMAN_TABLE_BASE_OFFSETS[4u]));
|
||||
while (true) {
|
||||
v_node = self->private_data.f_huffman_nodes[v_hg][v_h];
|
||||
if (v_node >= 32768u) {
|
||||
break;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
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_5 = *iop_a_src++;
|
||||
v_c8 = t_5;
|
||||
}
|
||||
self->private_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_h = ((((uint32_t)(v_node)) & 4095u) + (self->private_impl.f_bits & 1u));
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
}
|
||||
v_back_ref_dist_sym = ((uint32_t)(((uint16_t)(v_node & 32767u))));
|
||||
if (v_back_ref_dist_sym < 4u) {
|
||||
v_back_ref_dist_premap_minus_1 = v_back_ref_dist_sym;
|
||||
} else if (v_back_ref_dist_sym < 40u) {
|
||||
v_back_ref_dist_n_bits = ((v_back_ref_dist_sym - 2u) >> 1u);
|
||||
v_back_ref_dist_premap_minus_1 = ((((uint32_t)(2u)) + (v_back_ref_dist_sym & 1u)) << v_back_ref_dist_n_bits);
|
||||
while (self->private_impl.f_n_bits < v_back_ref_dist_n_bits) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
uint8_t t_6 = *iop_a_src++;
|
||||
v_c8 = t_6;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= v_back_ref_dist_n_bits) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_back_ref_dist_premap_minus_1 += (self->private_impl.f_bits & ((((uint32_t)(1u)) << v_back_ref_dist_n_bits) - 1u));
|
||||
self->private_impl.f_bits >>= v_back_ref_dist_n_bits;
|
||||
self->private_impl.f_n_bits -= v_back_ref_dist_n_bits;
|
||||
}
|
||||
if (v_back_ref_dist_premap_minus_1 >= 120u) {
|
||||
v_back_ref_dist_minus_1 = (v_back_ref_dist_premap_minus_1 - 120u);
|
||||
} else {
|
||||
v_dm = ((uint32_t)(WUFFS_WEBP__DISTANCE_MAP[v_back_ref_dist_premap_minus_1]));
|
||||
v_dy = (v_dm >> 4u);
|
||||
v_dx = ((uint32_t)(7u - (v_dm & 15u)));
|
||||
v_back_ref_dist_minus_1 = ((uint32_t)((a_width * v_dy) + v_dx));
|
||||
}
|
||||
v_p_end = (v_p + ((uint64_t)(((v_back_ref_len_minus_1 + 1u) * 4u))));
|
||||
v_dist4 = ((((uint64_t)(v_back_ref_dist_minus_1)) * 4u) + 4u);
|
||||
if ((v_p_end > v_p_max) || (v_p_end > ((uint64_t)(a_dst.len))) || (v_p < v_dist4)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_back_reference);
|
||||
goto exit;
|
||||
}
|
||||
v_q = (v_p - v_dist4);
|
||||
while ((v_q < v_p) && (v_p < v_p_end)) {
|
||||
a_dst.ptr[v_p] = a_dst.ptr[v_q];
|
||||
v_p += 1u;
|
||||
v_q += 1u;
|
||||
}
|
||||
v_x += (v_back_ref_len_minus_1 + 1u);
|
||||
while (v_x >= a_width) {
|
||||
v_x -= a_width;
|
||||
v_y += 1u;
|
||||
}
|
||||
continue;
|
||||
} else {
|
||||
if ((v_color_cache_p > v_p) || (v_p > ((uint64_t)(a_dst.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
|
||||
goto exit;
|
||||
}
|
||||
v_color_cache_pixels = wuffs_base__slice_u8__subslice_ij(a_dst, v_color_cache_p, v_p);
|
||||
v_color_cache_p = v_p;
|
||||
v_color_cache_shift = ((32u - self->private_impl.f_color_cache_bits) & 31u);
|
||||
while (((uint64_t)(v_color_cache_pixels.len)) >= 4u) {
|
||||
v_color = wuffs_base__peek_u32le__no_bounds_check(v_color_cache_pixels.ptr);
|
||||
self->private_data.f_color_cache[((((uint32_t)(v_color * 506832829u)) >> v_color_cache_shift) & 2047u)] = v_color;
|
||||
v_color_cache_pixels = wuffs_base__slice_u8__subslice_i(v_color_cache_pixels, 4u);
|
||||
}
|
||||
v_color = self->private_data.f_color_cache[((v_pixel_g - 280u) & 2047u)];
|
||||
}
|
||||
if (v_p > ((uint64_t)(a_dst.len))) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
|
||||
goto exit;
|
||||
}
|
||||
v_dst_pixel = wuffs_base__slice_u8__subslice_i(a_dst, v_p);
|
||||
if (((uint64_t)(v_dst_pixel.len)) < 4u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_dst_buffer);
|
||||
goto exit;
|
||||
}
|
||||
wuffs_base__poke_u32le__no_bounds_check(v_dst_pixel.ptr, v_color);
|
||||
v_p += 4u;
|
||||
v_x += 1u;
|
||||
if (v_x == a_width) {
|
||||
v_x = 0u;
|
||||
v_y += 1u;
|
||||
}
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_pixels_slow = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_pixels_slow = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_pixels_slow.v_p = v_p;
|
||||
self->private_data.s_decode_pixels_slow.v_p_max = v_p_max;
|
||||
self->private_data.s_decode_pixels_slow.v_tile_size_log2 = v_tile_size_log2;
|
||||
self->private_data.s_decode_pixels_slow.v_width_in_tiles = v_width_in_tiles;
|
||||
self->private_data.s_decode_pixels_slow.v_x = v_x;
|
||||
self->private_data.s_decode_pixels_slow.v_y = v_y;
|
||||
self->private_data.s_decode_pixels_slow.v_hg = v_hg;
|
||||
self->private_data.s_decode_pixels_slow.v_node = v_node;
|
||||
self->private_data.s_decode_pixels_slow.v_color = v_color;
|
||||
self->private_data.s_decode_pixels_slow.v_back_ref_len_n_bits = v_back_ref_len_n_bits;
|
||||
self->private_data.s_decode_pixels_slow.v_back_ref_len_minus_1 = v_back_ref_len_minus_1;
|
||||
self->private_data.s_decode_pixels_slow.v_back_ref_dist_n_bits = v_back_ref_dist_n_bits;
|
||||
self->private_data.s_decode_pixels_slow.v_back_ref_dist_premap_minus_1 = v_back_ref_dist_premap_minus_1;
|
||||
self->private_data.s_decode_pixels_slow.v_color_cache_p = v_color_cache_p;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.apply_transform_predictor
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_predictor(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
wuffs_base__slice_u8 a_tile_data) {
|
||||
uint64_t v_w4 = 0;
|
||||
wuffs_base__slice_u8 v_prev_row = {0};
|
||||
wuffs_base__slice_u8 v_curr_row = {0};
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_tiles_per_row = 0;
|
||||
uint32_t v_mask = 0;
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
uint64_t v_t = 0;
|
||||
wuffs_base__slice_u8 v_tile_data = {0};
|
||||
uint8_t v_mode = 0;
|
||||
uint32_t v_l0 = 0;
|
||||
uint32_t v_l1 = 0;
|
||||
uint32_t v_l2 = 0;
|
||||
uint32_t v_l3 = 0;
|
||||
uint32_t v_c0 = 0;
|
||||
uint32_t v_c1 = 0;
|
||||
uint32_t v_c2 = 0;
|
||||
uint32_t v_c3 = 0;
|
||||
uint32_t v_t0 = 0;
|
||||
uint32_t v_t1 = 0;
|
||||
uint32_t v_t2 = 0;
|
||||
uint32_t v_t3 = 0;
|
||||
uint32_t v_sum_l = 0;
|
||||
uint32_t v_sum_t = 0;
|
||||
|
||||
if ((self->private_impl.f_width <= 0u) || (self->private_impl.f_height <= 0u)) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
v_w4 = ((uint64_t)((self->private_impl.f_width * 4u)));
|
||||
v_curr_row = wuffs_base__utility__empty_slice_u8();
|
||||
if (v_w4 <= ((uint64_t)(a_pix.len))) {
|
||||
v_curr_row = wuffs_base__slice_u8__subslice_j(a_pix, v_w4);
|
||||
}
|
||||
if (((uint64_t)(v_curr_row.len)) >= 4u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[3u] += 255u;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
}
|
||||
while (((uint64_t)(v_curr_row.len)) >= 8u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += v_curr_row.ptr[0u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += v_curr_row.ptr[1u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += v_curr_row.ptr[2u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
|
||||
}
|
||||
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[0u]));
|
||||
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
|
||||
v_y = 1u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row)));
|
||||
v_tile_data = wuffs_base__utility__empty_slice_u8();
|
||||
if (v_t <= ((uint64_t)(a_tile_data.len))) {
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
|
||||
if (((uint64_t)(v_tile_data.len)) >= 4u) {
|
||||
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
|
||||
}
|
||||
}
|
||||
if (v_w4 <= ((uint64_t)(a_pix.len))) {
|
||||
v_prev_row = a_pix;
|
||||
a_pix = wuffs_base__slice_u8__subslice_i(a_pix, v_w4);
|
||||
v_curr_row = a_pix;
|
||||
}
|
||||
if ((((uint64_t)(v_prev_row.len)) >= 4u) && (((uint64_t)(v_curr_row.len)) >= 4u)) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[0u] += v_prev_row.ptr[0u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[1u] += v_prev_row.ptr[1u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[2u] += v_prev_row.ptr[2u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[3u] += v_prev_row.ptr[3u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
}
|
||||
v_x = 1u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
|
||||
v_mode = ((uint8_t)(v_tile_data.ptr[1u] & 15u));
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
|
||||
}
|
||||
if ((((uint64_t)(v_prev_row.len)) < 12u) || (((uint64_t)(v_curr_row.len)) < 8u)) {
|
||||
break;
|
||||
}
|
||||
if (v_mode == 0u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += 255u;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 1u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += v_curr_row.ptr[0u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += v_curr_row.ptr[1u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += v_curr_row.ptr[2u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += v_curr_row.ptr[3u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 2u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += v_prev_row.ptr[4u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += v_prev_row.ptr[5u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += v_prev_row.ptr[6u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += v_prev_row.ptr[7u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 3u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += v_prev_row.ptr[8u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += v_prev_row.ptr[9u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += v_prev_row.ptr[10u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += v_prev_row.ptr[11u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 4u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += v_prev_row.ptr[0u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += v_prev_row.ptr[1u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += v_prev_row.ptr[2u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += v_prev_row.ptr[3u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 5u) {
|
||||
v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u);
|
||||
v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u);
|
||||
v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u);
|
||||
v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 6u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 7u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 8u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[4u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[5u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[6u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[7u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 9u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 10u) {
|
||||
v_l0 = ((((uint32_t)(v_curr_row.ptr[0u])) + ((uint32_t)(v_prev_row.ptr[0u]))) / 2u);
|
||||
v_l1 = ((((uint32_t)(v_curr_row.ptr[1u])) + ((uint32_t)(v_prev_row.ptr[1u]))) / 2u);
|
||||
v_l2 = ((((uint32_t)(v_curr_row.ptr[2u])) + ((uint32_t)(v_prev_row.ptr[2u]))) / 2u);
|
||||
v_l3 = ((((uint32_t)(v_curr_row.ptr[3u])) + ((uint32_t)(v_prev_row.ptr[3u]))) / 2u);
|
||||
v_t0 = ((((uint32_t)(v_prev_row.ptr[4u])) + ((uint32_t)(v_prev_row.ptr[8u]))) / 2u);
|
||||
v_t1 = ((((uint32_t)(v_prev_row.ptr[5u])) + ((uint32_t)(v_prev_row.ptr[9u]))) / 2u);
|
||||
v_t2 = ((((uint32_t)(v_prev_row.ptr[6u])) + ((uint32_t)(v_prev_row.ptr[10u]))) / 2u);
|
||||
v_t3 = ((((uint32_t)(v_prev_row.ptr[7u])) + ((uint32_t)(v_prev_row.ptr[11u]))) / 2u);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(((v_l0 + v_t0) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(((v_l1 + v_t1) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(((v_l2 + v_t2) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(((v_l3 + v_t3) / 2u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 11u) {
|
||||
v_l0 = ((uint32_t)(v_curr_row.ptr[0u]));
|
||||
v_l1 = ((uint32_t)(v_curr_row.ptr[1u]));
|
||||
v_l2 = ((uint32_t)(v_curr_row.ptr[2u]));
|
||||
v_l3 = ((uint32_t)(v_curr_row.ptr[3u]));
|
||||
v_c0 = ((uint32_t)(v_prev_row.ptr[0u]));
|
||||
v_c1 = ((uint32_t)(v_prev_row.ptr[1u]));
|
||||
v_c2 = ((uint32_t)(v_prev_row.ptr[2u]));
|
||||
v_c3 = ((uint32_t)(v_prev_row.ptr[3u]));
|
||||
v_t0 = ((uint32_t)(v_prev_row.ptr[4u]));
|
||||
v_t1 = ((uint32_t)(v_prev_row.ptr[5u]));
|
||||
v_t2 = ((uint32_t)(v_prev_row.ptr[6u]));
|
||||
v_t3 = ((uint32_t)(v_prev_row.ptr[7u]));
|
||||
v_sum_l = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_t0) +
|
||||
wuffs_webp__decoder__absolute_difference(self, v_c1, v_t1) +
|
||||
wuffs_webp__decoder__absolute_difference(self, v_c2, v_t2) +
|
||||
wuffs_webp__decoder__absolute_difference(self, v_c3, v_t3));
|
||||
v_sum_t = (wuffs_webp__decoder__absolute_difference(self, v_c0, v_l0) +
|
||||
wuffs_webp__decoder__absolute_difference(self, v_c1, v_l1) +
|
||||
wuffs_webp__decoder__absolute_difference(self, v_c2, v_l2) +
|
||||
wuffs_webp__decoder__absolute_difference(self, v_c3, v_l3));
|
||||
if (v_sum_l < v_sum_t) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(v_l0));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(v_l1));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(v_l2));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(v_l3));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += ((uint8_t)(v_t0));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += ((uint8_t)(v_t1));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += ((uint8_t)(v_t2));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += ((uint8_t)(v_t3));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
}
|
||||
} else if (v_mode == 12u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += wuffs_webp__decoder__mode12(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else if (v_mode == 13u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[4u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[0u], v_prev_row.ptr[4u], v_prev_row.ptr[0u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[5u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[1u], v_prev_row.ptr[5u], v_prev_row.ptr[1u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[6u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[2u], v_prev_row.ptr[6u], v_prev_row.ptr[2u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_curr_row.ptr[7u] += wuffs_webp__decoder__mode13(self, v_curr_row.ptr[3u], v_prev_row.ptr[7u], v_prev_row.ptr[3u]);
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
}
|
||||
v_curr_row = wuffs_base__slice_u8__subslice_i(v_curr_row, 4u);
|
||||
v_prev_row = wuffs_base__slice_u8__subslice_i(v_prev_row, 4u);
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.absolute_difference
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint32_t
|
||||
wuffs_webp__decoder__absolute_difference(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint32_t a_a,
|
||||
uint32_t a_b) {
|
||||
if (a_a < a_b) {
|
||||
return (a_b - a_a);
|
||||
}
|
||||
return (a_a - a_b);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.mode12
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint8_t
|
||||
wuffs_webp__decoder__mode12(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint8_t a_l,
|
||||
uint8_t a_t,
|
||||
uint8_t a_tl) {
|
||||
uint32_t v_v = 0;
|
||||
|
||||
v_v = ((uint32_t)((((uint32_t)(a_l)) + ((uint32_t)(a_t))) - ((uint32_t)(a_tl))));
|
||||
if (v_v < 256u) {
|
||||
return ((uint8_t)(v_v));
|
||||
} else if (v_v < 512u) {
|
||||
return 255u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.mode13
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static uint8_t
|
||||
wuffs_webp__decoder__mode13(
|
||||
const wuffs_webp__decoder* self,
|
||||
uint8_t a_l,
|
||||
uint8_t a_t,
|
||||
uint8_t a_tl) {
|
||||
uint32_t v_x = 0;
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_z = 0;
|
||||
uint32_t v_v = 0;
|
||||
|
||||
v_x = ((((uint32_t)(a_l)) + ((uint32_t)(a_t))) / 2u);
|
||||
v_y = ((uint32_t)(a_tl));
|
||||
v_z = ((uint32_t)(v_x - v_y));
|
||||
v_v = ((uint32_t)(v_x + wuffs_base__utility__sign_extend_rshift_u32(((uint32_t)(v_z + (v_z >> 31u))), 1u)));
|
||||
if (v_v < 256u) {
|
||||
return ((uint8_t)(v_v));
|
||||
} else if (v_v < 512u) {
|
||||
return 255u;
|
||||
}
|
||||
return 0u;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.apply_transform_cross_color
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_cross_color(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix,
|
||||
wuffs_base__slice_u8 a_tile_data) {
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_tiles_per_row = 0;
|
||||
uint32_t v_mask = 0;
|
||||
uint32_t v_y = 0;
|
||||
uint32_t v_x = 0;
|
||||
uint64_t v_t = 0;
|
||||
wuffs_base__slice_u8 v_tile_data = {0};
|
||||
uint32_t v_g2r = 0;
|
||||
uint32_t v_g2b = 0;
|
||||
uint32_t v_r2b = 0;
|
||||
uint8_t v_b = 0;
|
||||
uint8_t v_g = 0;
|
||||
uint8_t v_r = 0;
|
||||
|
||||
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[1u]));
|
||||
v_tiles_per_row = ((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2);
|
||||
v_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
|
||||
v_y = 0u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_t = ((uint64_t)((4u * (v_y >> v_tile_size_log2) * v_tiles_per_row)));
|
||||
v_tile_data = wuffs_base__utility__empty_slice_u8();
|
||||
if (v_t <= ((uint64_t)(a_tile_data.len))) {
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(a_tile_data, v_t);
|
||||
}
|
||||
v_x = 0u;
|
||||
while (v_x < self->private_impl.f_width) {
|
||||
if (((v_x & v_mask) == 0u) && (((uint64_t)(v_tile_data.len)) >= 4u)) {
|
||||
v_g2r = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[0u]];
|
||||
v_g2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[1u]];
|
||||
v_r2b = WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_tile_data.ptr[2u]];
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_i(v_tile_data, 4u);
|
||||
}
|
||||
if (((uint64_t)(a_pix.len)) >= 4u) {
|
||||
v_b = a_pix.ptr[0u];
|
||||
v_g = a_pix.ptr[1u];
|
||||
v_r = a_pix.ptr[2u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_r += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2r)) >> 5u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_g] * v_g2b)) >> 5u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_b += ((uint8_t)((((uint32_t)(WUFFS_WEBP__SIGN_EXTEND_I8_I32[v_r] * v_r2b)) >> 5u)));
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
a_pix.ptr[0u] = v_b;
|
||||
a_pix.ptr[2u] = v_r;
|
||||
a_pix = wuffs_base__slice_u8__subslice_i(a_pix, 4u);
|
||||
}
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.apply_transform_subtract_green
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_subtract_green(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix) {
|
||||
wuffs_base__slice_u8 v_p = {0};
|
||||
uint8_t v_g = 0;
|
||||
|
||||
{
|
||||
wuffs_base__slice_u8 i_slice_p = a_pix;
|
||||
v_p.ptr = i_slice_p.ptr;
|
||||
v_p.len = 4;
|
||||
const uint8_t* i_end0_p = wuffs_private_impl__ptr_u8_plus_len(v_p.ptr, (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 4) * 4));
|
||||
while (v_p.ptr < i_end0_p) {
|
||||
v_g = v_p.ptr[1u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_p.ptr[0u] += v_g;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_p.ptr[2u] += v_g;
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
v_p.ptr += 4;
|
||||
}
|
||||
v_p.len = 0;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.apply_transform_color_indexing
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_pix) {
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
uint32_t v_bits_per_pixel = 0;
|
||||
uint32_t v_x_mask = 0;
|
||||
uint32_t v_s_mask = 0;
|
||||
uint64_t v_src_index = 0;
|
||||
uint32_t v_y = 0;
|
||||
uint64_t v_di = 0;
|
||||
uint64_t v_dj = 0;
|
||||
wuffs_base__slice_u8 v_dst = {0};
|
||||
uint32_t v_x = 0;
|
||||
uint32_t v_s = 0;
|
||||
uint32_t v_p = 0;
|
||||
uint8_t v_p0 = 0;
|
||||
uint8_t v_p1 = 0;
|
||||
uint8_t v_p2 = 0;
|
||||
uint8_t v_p3 = 0;
|
||||
|
||||
v_tile_size_log2 = ((uint32_t)(self->private_impl.f_transform_tile_size_log2[3u]));
|
||||
if (v_tile_size_log2 == 0u) {
|
||||
}
|
||||
v_bits_per_pixel = (((uint32_t)(8u)) >> v_tile_size_log2);
|
||||
v_x_mask = ((((uint32_t)(1u)) << v_tile_size_log2) - 1u);
|
||||
v_s_mask = ((((uint32_t)(1u)) << v_bits_per_pixel) - 1u);
|
||||
v_src_index = ((uint64_t)((self->private_impl.f_workbuf_offset_for_color_indexing + 1u)));
|
||||
v_y = 0u;
|
||||
while (v_y < self->private_impl.f_height) {
|
||||
v_di = ((uint64_t)((4u * (v_y + 0u) * self->private_impl.f_width)));
|
||||
v_dj = ((uint64_t)((4u * (v_y + 1u) * self->private_impl.f_width)));
|
||||
if ((v_di > v_dj) || (v_dj > ((uint64_t)(a_pix.len)))) {
|
||||
break;
|
||||
}
|
||||
v_dst = wuffs_base__slice_u8__subslice_ij(a_pix, v_di, v_dj);
|
||||
v_x = 0u;
|
||||
while (((uint64_t)(v_dst.len)) >= 4u) {
|
||||
if (((v_x & v_x_mask) == 0u) && (v_src_index < ((uint64_t)(a_pix.len)))) {
|
||||
v_s = ((uint32_t)(a_pix.ptr[v_src_index]));
|
||||
v_src_index += 4u;
|
||||
}
|
||||
v_p = ((v_s & v_s_mask) * 4u);
|
||||
v_s >>= v_bits_per_pixel;
|
||||
v_p0 = self->private_data.f_palette[(v_p + 0u)];
|
||||
v_p1 = self->private_data.f_palette[(v_p + 1u)];
|
||||
v_p2 = self->private_data.f_palette[(v_p + 2u)];
|
||||
v_p3 = self->private_data.f_palette[(v_p + 3u)];
|
||||
v_dst.ptr[0u] = v_p0;
|
||||
v_dst.ptr[1u] = v_p1;
|
||||
v_dst.ptr[2u] = v_p2;
|
||||
v_dst.ptr[3u] = v_p3;
|
||||
v_dst = wuffs_base__slice_u8__subslice_i(v_dst, 4u);
|
||||
v_x += 1u;
|
||||
}
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.get_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -69417,29 +71863,478 @@ wuffs_webp__decoder__do_decode_image_config(
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
if (self->private_impl.f_call_sequence != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
uint32_t v_c32 = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_call_sequence);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 1179011410u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_riff_chunk_length = t_1;
|
||||
}
|
||||
if ((self->private_impl.f_riff_chunk_length & 1u) != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_riff_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_2 = wuffs_webp__decoder__do_decode_image_config_limited(self, a_src);
|
||||
v_status = t_2;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_riff_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_riff_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(5);
|
||||
}
|
||||
self->private_impl.f_frame_config_io_position = wuffs_base__u64__sat_add((a_src ? a_src->meta.pos : 0), ((uint64_t)(iop_a_src - io0_a_src)));
|
||||
if (a_dst != NULL) {
|
||||
wuffs_base__image_config__set(
|
||||
a_dst,
|
||||
self->private_impl.f_pixfmt,
|
||||
0u,
|
||||
self->private_impl.f_width,
|
||||
self->private_impl.f_height,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
false);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 32u;
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config = 0;
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_pixfmt = 2164295816u;
|
||||
self->private_impl.f_width = 160u;
|
||||
self->private_impl.f_height = 120u;
|
||||
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,
|
||||
self->private_impl.f_frame_config_io_position,
|
||||
false);
|
||||
}
|
||||
self->private_impl.f_call_sequence = 32u;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint64_t v_r_mark = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
uint32_t t_0;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_0 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_0 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_0;
|
||||
if (num_bits_0 == 24) {
|
||||
t_0 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_0 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_0)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 1346520407u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
if (v_c32 == 540561494u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
} else if (v_c32 == 1278758998u) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
uint32_t t_2;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_2 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited.scratch;
|
||||
uint32_t num_bits_2 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_2;
|
||||
if (num_bits_2 == 24) {
|
||||
t_2 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_2 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_2)) << 56;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_sub_chunk_length = t_2;
|
||||
}
|
||||
if (self->private_impl.f_sub_chunk_length < 4u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_sub_chunk_has_padding = ((self->private_impl.f_sub_chunk_length & 1u) != 0u);
|
||||
while (true) {
|
||||
{
|
||||
const bool o_0_closed_a_src = a_src->meta.closed;
|
||||
const uint8_t* o_0_io2_a_src = io2_a_src;
|
||||
wuffs_private_impl__io_reader__limit(&io2_a_src, iop_a_src,
|
||||
((uint64_t)(self->private_impl.f_sub_chunk_length)));
|
||||
if (a_src) {
|
||||
size_t n = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
a_src->meta.closed = a_src->meta.closed && (a_src->meta.wi <= n);
|
||||
a_src->meta.wi = n;
|
||||
}
|
||||
v_r_mark = ((uint64_t)(iop_a_src - io0_a_src));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_3 = wuffs_webp__decoder__do_decode_image_config_limited_vp8l(self, a_src);
|
||||
v_status = t_3;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
wuffs_private_impl__u32__sat_sub_indirect(&self->private_impl.f_sub_chunk_length, ((uint32_t)(wuffs_private_impl__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src))))));
|
||||
io2_a_src = o_0_io2_a_src;
|
||||
if (a_src) {
|
||||
a_src->meta.closed = o_0_closed_a_src;
|
||||
a_src->meta.wi = ((size_t)(io2_a_src - a_src->data.ptr));
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
} else if ( ! wuffs_base__status__is_suspension(&v_status)) {
|
||||
status = v_status;
|
||||
if (wuffs_base__status__is_error(&status)) {
|
||||
goto exit;
|
||||
} else if (wuffs_base__status__is_suspension(&status)) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__cannot_return_a_suspension);
|
||||
goto exit;
|
||||
}
|
||||
goto ok;
|
||||
} else if ((v_status.repr == wuffs_base__suspension__short_read) && (self->private_impl.f_sub_chunk_length == 0u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__short_chunk);
|
||||
goto exit;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
}
|
||||
} else if (v_c32 == 1480085590u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_webp_file);
|
||||
goto exit;
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.do_decode_image_config_limited_vp8l
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__do_decode_image_config_limited_vp8l(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_c32 = 0;
|
||||
uint32_t v_transform_size = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_image_config_limited_vp8l;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint32_t t_0 = *iop_a_src++;
|
||||
v_c32 = t_0;
|
||||
}
|
||||
if (v_c32 != 47u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(2);
|
||||
uint32_t t_1;
|
||||
if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) {
|
||||
t_1 = wuffs_base__peek_u32le__no_bounds_check(iop_a_src);
|
||||
iop_a_src += 4;
|
||||
} else {
|
||||
self->private_data.s_do_decode_image_config_limited_vp8l.scratch = 0;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
while (true) {
|
||||
if (WUFFS_BASE__UNLIKELY(iop_a_src == io2_a_src)) {
|
||||
status = wuffs_base__make_status(wuffs_base__suspension__short_read);
|
||||
goto suspend;
|
||||
}
|
||||
uint64_t* scratch = &self->private_data.s_do_decode_image_config_limited_vp8l.scratch;
|
||||
uint32_t num_bits_1 = ((uint32_t)(*scratch >> 56));
|
||||
*scratch <<= 8;
|
||||
*scratch >>= 8;
|
||||
*scratch |= ((uint64_t)(*iop_a_src++)) << num_bits_1;
|
||||
if (num_bits_1 == 24) {
|
||||
t_1 = ((uint32_t)(*scratch));
|
||||
break;
|
||||
}
|
||||
num_bits_1 += 8u;
|
||||
*scratch |= ((uint64_t)(num_bits_1)) << 56;
|
||||
}
|
||||
}
|
||||
v_c32 = t_1;
|
||||
}
|
||||
self->private_impl.f_width = ((v_c32 & 16383u) + 1u);
|
||||
v_c32 >>= 14u;
|
||||
self->private_impl.f_height = ((v_c32 & 16383u) + 1u);
|
||||
v_c32 >>= 14u;
|
||||
self->private_impl.f_pixfmt = 2415954056u;
|
||||
if ((v_c32 & 1u) != 0u) {
|
||||
self->private_impl.f_pixfmt = 2164295816u;
|
||||
}
|
||||
v_c32 >>= 1u;
|
||||
if (v_c32 != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_header);
|
||||
goto exit;
|
||||
}
|
||||
v_transform_size = (4u * ((self->private_impl.f_width + 3u) >> 2u) * ((self->private_impl.f_height + 3u) >> 2u));
|
||||
self->private_impl.f_workbuf_offset_for_transform[0u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (0u * v_transform_size));
|
||||
self->private_impl.f_workbuf_offset_for_transform[1u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (1u * v_transform_size));
|
||||
self->private_impl.f_workbuf_offset_for_transform[2u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (2u * v_transform_size));
|
||||
self->private_impl.f_workbuf_offset_for_transform[3u] = ((4u * self->private_impl.f_width * self->private_impl.f_height) + (3u * v_transform_size));
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8l = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_do_decode_image_config_limited_vp8l = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
@@ -69683,15 +72578,873 @@ wuffs_webp__decoder__do_decode_frame(
|
||||
wuffs_base__decode_frame_options* a_opts) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
self->private_impl.f_call_sequence = 96u;
|
||||
uint8_t v_c8 = 0;
|
||||
uint32_t v_has_more = 0;
|
||||
uint32_t v_width = 0;
|
||||
wuffs_base__slice_u8 v_dst = {0};
|
||||
wuffs_base__slice_u8 v_tile_data = {0};
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
wuffs_base__slice_u8 v_pix = {0};
|
||||
uint32_t v_which = 0;
|
||||
uint32_t v_transform_type = 0;
|
||||
uint64_t v_ti = 0;
|
||||
uint64_t v_tj = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_do_decode_frame;
|
||||
if (coro_susp_point) {
|
||||
v_width = self->private_data.s_do_decode_frame.v_width;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_call_sequence == 64u) {
|
||||
} else if (self->private_impl.f_call_sequence < 64u) {
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__do_decode_frame_config(self, NULL, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else {
|
||||
status = wuffs_base__make_status(wuffs_base__note__end_of_data);
|
||||
goto ok;
|
||||
}
|
||||
self->private_impl.f_seen_transform[0u] = false;
|
||||
self->private_impl.f_seen_transform[1u] = false;
|
||||
self->private_impl.f_seen_transform[2u] = false;
|
||||
self->private_impl.f_seen_transform[3u] = false;
|
||||
self->private_impl.f_n_transforms = 0u;
|
||||
while (true) {
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_0 = *iop_a_src++;
|
||||
v_c8 = t_0;
|
||||
}
|
||||
self->private_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_has_more = (self->private_impl.f_bits & 1u);
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
if (v_has_more == 0u) {
|
||||
break;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_webp__decoder__decode_transform(self, a_src, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
}
|
||||
v_width = self->private_impl.f_width;
|
||||
if (self->private_impl.f_seen_transform[3u]) {
|
||||
v_width = self->private_impl.f_color_indexing_width;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_overall_color_cache_bits = self->private_impl.f_color_cache_bits;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_webp__decoder__decode_hg_table(self, a_src, v_width, a_workbuf);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_color_cache_bits = self->private_impl.f_overall_color_cache_bits;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, self->private_impl.f_overall_n_huffman_groups);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
while (true) {
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u]))) ||
|
||||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) ||
|
||||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len))) ||
|
||||
(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_dst = wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_color_indexing)),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
|
||||
{
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
wuffs_base__status t_1 = wuffs_webp__decoder__decode_pixels(self,
|
||||
v_dst,
|
||||
a_src,
|
||||
v_width,
|
||||
self->private_impl.f_height,
|
||||
v_tile_data,
|
||||
self->private_impl.f_overall_tile_size_log2);
|
||||
v_status = t_1;
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
}
|
||||
if (wuffs_base__status__is_ok(&v_status)) {
|
||||
break;
|
||||
}
|
||||
status = v_status;
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(7);
|
||||
}
|
||||
if (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(a_workbuf.len))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_pix = wuffs_base__slice_u8__subslice_j(a_workbuf, ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])));
|
||||
v_which = self->private_impl.f_n_transforms;
|
||||
while (v_which > 0u) {
|
||||
v_which -= 1u;
|
||||
v_transform_type = ((uint32_t)(self->private_impl.f_transform_type[v_which]));
|
||||
v_tile_data = wuffs_base__utility__empty_slice_u8();
|
||||
if (v_transform_type < 2u) {
|
||||
v_ti = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)]));
|
||||
v_tj = ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]));
|
||||
if ((v_ti <= v_tj) && (v_tj <= ((uint64_t)(a_workbuf.len)))) {
|
||||
v_tile_data = wuffs_base__slice_u8__subslice_ij(a_workbuf, v_ti, v_tj);
|
||||
}
|
||||
}
|
||||
if (v_transform_type == 0u) {
|
||||
wuffs_webp__decoder__apply_transform_predictor(self, v_pix, v_tile_data);
|
||||
} else if (v_transform_type == 1u) {
|
||||
wuffs_webp__decoder__apply_transform_cross_color(self, v_pix, v_tile_data);
|
||||
} else if (v_transform_type == 2u) {
|
||||
wuffs_webp__decoder__apply_transform_subtract_green(self, v_pix);
|
||||
} else {
|
||||
wuffs_webp__decoder__apply_transform_color_indexing(self, v_pix);
|
||||
v_width = self->private_impl.f_width;
|
||||
}
|
||||
}
|
||||
v_status = wuffs_webp__decoder__swizzle(self, a_dst, v_pix, 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_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_width = v_width;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_transform
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_transform(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
wuffs_base__slice_u8 a_workbuf) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c8 = 0;
|
||||
uint32_t v_transform_type = 0;
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
wuffs_base__slice_u8 v_p = {0};
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_transform;
|
||||
if (coro_susp_point) {
|
||||
v_transform_type = self->private_data.s_decode_transform.v_transform_type;
|
||||
v_tile_size_log2 = self->private_data.s_decode_transform.v_tile_size_log2;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_n_bits < 2u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 2u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_transform_type = (self->private_impl.f_bits & 3u);
|
||||
self->private_impl.f_bits >>= 2u;
|
||||
self->private_impl.f_n_bits -= 2u;
|
||||
if (self->private_impl.f_seen_transform[v_transform_type] || (self->private_impl.f_n_transforms >= 4u)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_transform);
|
||||
goto exit;
|
||||
} else if (self->private_impl.f_seen_transform[3u]) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_transform_after_color_indexing_transform);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_seen_transform[v_transform_type] = true;
|
||||
self->private_impl.f_transform_type[self->private_impl.f_n_transforms] = ((uint8_t)(v_transform_type));
|
||||
self->private_impl.f_n_transforms += 1u;
|
||||
if (v_transform_type < 2u) {
|
||||
if (self->private_impl.f_n_bits < 3u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 3u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u);
|
||||
self->private_impl.f_transform_tile_size_log2[v_transform_type] = ((uint8_t)(v_tile_size_log2));
|
||||
self->private_impl.f_bits >>= 3u;
|
||||
self->private_impl.f_n_bits -= 3u;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_webp__decoder__decode_pixels(self,
|
||||
wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 1u)])),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[(v_transform_type + 2u)]))),
|
||||
a_src,
|
||||
((self->private_impl.f_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
0u);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
} else if (v_transform_type == 2u) {
|
||||
} else {
|
||||
if (self->private_impl.f_n_bits < 8u) {
|
||||
{
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(6);
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 8u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
self->private_impl.f_color_indexing_palette_size = ((self->private_impl.f_bits & 255u) + 1u);
|
||||
self->private_impl.f_bits >>= 8u;
|
||||
self->private_impl.f_n_bits -= 8u;
|
||||
if (self->private_impl.f_color_indexing_palette_size <= 2u) {
|
||||
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 7u) / 8u);
|
||||
self->private_impl.f_transform_tile_size_log2[3u] = 3u;
|
||||
} else if (self->private_impl.f_color_indexing_palette_size <= 4u) {
|
||||
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 3u) / 4u);
|
||||
self->private_impl.f_transform_tile_size_log2[3u] = 2u;
|
||||
} else if (self->private_impl.f_color_indexing_palette_size <= 16u) {
|
||||
self->private_impl.f_color_indexing_width = ((self->private_impl.f_width + 1u) / 2u);
|
||||
self->private_impl.f_transform_tile_size_log2[3u] = 1u;
|
||||
} else {
|
||||
self->private_impl.f_color_indexing_width = self->private_impl.f_width;
|
||||
self->private_impl.f_transform_tile_size_log2[3u] = 0u;
|
||||
}
|
||||
if (self->private_impl.f_width >= self->private_impl.f_color_indexing_width) {
|
||||
self->private_impl.f_workbuf_offset_for_color_indexing = (4u * (self->private_impl.f_width - self->private_impl.f_color_indexing_width) * self->private_impl.f_height);
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7);
|
||||
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8);
|
||||
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9);
|
||||
status = wuffs_webp__decoder__decode_pixels(self,
|
||||
wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size)),
|
||||
a_src,
|
||||
self->private_impl.f_color_indexing_palette_size,
|
||||
1u,
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
0u);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
wuffs_private_impl__bulk_memset(&self->private_data.f_palette[(4u * self->private_impl.f_color_indexing_palette_size)], (1024u - (4u * self->private_impl.f_color_indexing_palette_size)), 0u);
|
||||
v_p = wuffs_base__make_slice_u8(self->private_data.f_palette, (4u * self->private_impl.f_color_indexing_palette_size));
|
||||
while (((uint64_t)(v_p.len)) >= 8u) {
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_p.ptr[4u] += v_p.ptr[0u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_p.ptr[5u] += v_p.ptr[1u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_p.ptr[6u] += v_p.ptr[2u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#endif
|
||||
v_p.ptr[7u] += v_p.ptr[3u];
|
||||
#if defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u);
|
||||
}
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_transform = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_transform = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_transform.v_transform_type = v_transform_type;
|
||||
self->private_data.s_decode_transform.v_tile_size_log2 = v_tile_size_log2;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_color_cache_parameters
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_color_cache_parameters(
|
||||
wuffs_webp__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_use_color_cache = 0;
|
||||
uint32_t v_color_cache_bits = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_color_cache_parameters;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_use_color_cache = (self->private_impl.f_bits & 1u);
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
self->private_impl.f_color_cache_bits = 0u;
|
||||
if (v_use_color_cache != 0u) {
|
||||
if (self->private_impl.f_n_bits < 4u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 4u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_color_cache_bits = (self->private_impl.f_bits & 15u);
|
||||
self->private_impl.f_bits >>= 4u;
|
||||
self->private_impl.f_n_bits -= 4u;
|
||||
if ((v_color_cache_bits < 1u) || (11u < v_color_cache_bits)) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__bad_color_cache);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_color_cache_bits = v_color_cache_bits;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_color_cache_parameters = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_color_cache_parameters = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_hg_table
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_hg_table(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_width,
|
||||
wuffs_base__slice_u8 a_workbuf) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint8_t v_c8 = 0;
|
||||
uint32_t v_use_hg_table = 0;
|
||||
uint32_t v_tile_size_log2 = 0;
|
||||
wuffs_base__slice_u8 v_hg_pixels = {0};
|
||||
uint64_t v_n = 0;
|
||||
wuffs_base__slice_u8 v_p = {0};
|
||||
uint32_t v_hg_plus_1 = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io1_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
const uint8_t* io2_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
if (a_src && a_src->data.ptr) {
|
||||
io0_a_src = a_src->data.ptr;
|
||||
io1_a_src = io0_a_src + a_src->meta.ri;
|
||||
iop_a_src = io1_a_src;
|
||||
io2_a_src = io0_a_src + a_src->meta.wi;
|
||||
}
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_hg_table;
|
||||
if (coro_susp_point) {
|
||||
v_tile_size_log2 = self->private_data.s_decode_hg_table.v_tile_size_log2;
|
||||
}
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
if (self->private_impl.f_n_bits < 1u) {
|
||||
{
|
||||
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_impl.f_bits = ((uint32_t)(v_c8));
|
||||
self->private_impl.f_n_bits = 8u;
|
||||
}
|
||||
v_use_hg_table = (self->private_impl.f_bits & 1u);
|
||||
self->private_impl.f_bits >>= 1u;
|
||||
self->private_impl.f_n_bits -= 1u;
|
||||
if (v_use_hg_table == 0u) {
|
||||
self->private_impl.f_overall_n_huffman_groups = 1u;
|
||||
self->private_impl.f_overall_tile_size_log2 = 0u;
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
|
||||
if (((uint64_t)(v_hg_pixels.len)) >= 4u) {
|
||||
v_hg_pixels.ptr[0u] = 0u;
|
||||
v_hg_pixels.ptr[1u] = 0u;
|
||||
v_hg_pixels.ptr[2u] = 0u;
|
||||
v_hg_pixels.ptr[3u] = 0u;
|
||||
}
|
||||
status = wuffs_base__make_status(NULL);
|
||||
goto ok;
|
||||
}
|
||||
if (self->private_impl.f_n_bits < 3u) {
|
||||
{
|
||||
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;
|
||||
}
|
||||
if (self->private_impl.f_n_bits >= 3u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__internal_error_inconsistent_n_bits);
|
||||
goto exit;
|
||||
}
|
||||
self->private_impl.f_bits |= (((uint32_t)(v_c8)) << self->private_impl.f_n_bits);
|
||||
self->private_impl.f_n_bits += 8u;
|
||||
}
|
||||
v_tile_size_log2 = ((self->private_impl.f_bits & 7u) + 2u);
|
||||
self->private_impl.f_bits >>= 3u;
|
||||
self->private_impl.f_n_bits -= 3u;
|
||||
self->private_impl.f_overall_tile_size_log2 = v_tile_size_log2;
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(3);
|
||||
status = wuffs_webp__decoder__decode_color_cache_parameters(self, a_src);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(4);
|
||||
status = wuffs_webp__decoder__decode_huffman_groups(self, a_src, 1u);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
if (a_src) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5);
|
||||
status = wuffs_webp__decoder__decode_pixels(self,
|
||||
wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))),
|
||||
a_src,
|
||||
((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2),
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
0u);
|
||||
if (a_src) {
|
||||
iop_a_src = a_src->data.ptr + a_src->meta.ri;
|
||||
}
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
self->private_impl.f_overall_n_huffman_groups = 1u;
|
||||
if ((((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])) > ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u]))) || (((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])) > ((uint64_t)(a_workbuf.len)))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_hg_pixels = wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[0u])),
|
||||
((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[1u])));
|
||||
v_n = ((uint64_t)((((a_width + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * ((self->private_impl.f_height + ((((uint32_t)(1u)) << v_tile_size_log2) - 1u)) >> v_tile_size_log2) * 4u)));
|
||||
if (v_n > ((uint64_t)(v_hg_pixels.len))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
v_p = wuffs_base__slice_u8__subslice_j(v_hg_pixels, v_n);
|
||||
while (((uint64_t)(v_p.len)) >= 4u) {
|
||||
if (v_p.ptr[2u] != 0u) {
|
||||
status = wuffs_base__make_status(wuffs_webp__error__unsupported_number_of_huffman_groups);
|
||||
goto exit;
|
||||
}
|
||||
v_hg_plus_1 = (((uint32_t)(v_p.ptr[1u])) + 1u);
|
||||
if (self->private_impl.f_overall_n_huffman_groups < v_hg_plus_1) {
|
||||
self->private_impl.f_overall_n_huffman_groups = v_hg_plus_1;
|
||||
}
|
||||
v_p = wuffs_base__slice_u8__subslice_i(v_p, 4u);
|
||||
}
|
||||
|
||||
ok:
|
||||
self->private_impl.p_decode_hg_table = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_hg_table = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
self->private_data.s_decode_hg_table.v_tile_size_log2 = v_tile_size_log2;
|
||||
|
||||
goto exit;
|
||||
exit:
|
||||
if (a_src && a_src->data.ptr) {
|
||||
a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.decode_pixels
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__decode_pixels(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__slice_u8 a_dst,
|
||||
wuffs_base__io_buffer* a_src,
|
||||
uint32_t a_width,
|
||||
uint32_t a_height,
|
||||
wuffs_base__slice_u8 a_tile_data,
|
||||
uint32_t a_tile_size_log2) {
|
||||
wuffs_base__status status = wuffs_base__make_status(NULL);
|
||||
|
||||
uint32_t v_i = 0;
|
||||
uint32_t v_n = 0;
|
||||
|
||||
uint32_t coro_susp_point = self->private_impl.p_decode_pixels;
|
||||
switch (coro_susp_point) {
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0;
|
||||
|
||||
v_i = 0u;
|
||||
v_n = (((uint32_t)(1u)) << self->private_impl.f_color_cache_bits);
|
||||
while (v_i < v_n) {
|
||||
self->private_data.f_color_cache[v_i] = 0u;
|
||||
v_i += 1u;
|
||||
}
|
||||
WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);
|
||||
status = wuffs_webp__decoder__decode_pixels_slow(self,
|
||||
a_dst,
|
||||
a_src,
|
||||
a_width,
|
||||
a_height,
|
||||
a_tile_data,
|
||||
a_tile_size_log2);
|
||||
if (status.repr) {
|
||||
goto suspend;
|
||||
}
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
self->private_impl.p_decode_pixels = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
goto suspend;
|
||||
suspend:
|
||||
self->private_impl.p_decode_pixels = wuffs_base__status__is_suspension(&status) ? coro_susp_point : 0;
|
||||
|
||||
goto ok;
|
||||
ok:
|
||||
goto exit;
|
||||
exit:
|
||||
return status;
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.swizzle
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__status
|
||||
wuffs_webp__decoder__swizzle(
|
||||
wuffs_webp__decoder* self,
|
||||
wuffs_base__pixel_buffer* a_dst,
|
||||
wuffs_base__slice_u8 a_src,
|
||||
wuffs_base__pixel_blend a_blend) {
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
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__slice_u8 v_dst_palette = {0};
|
||||
wuffs_base__table_u8 v_tab = {0};
|
||||
uint64_t v_src_bytes_per_row = 0;
|
||||
wuffs_base__slice_u8 v_dst = {0};
|
||||
uint32_t v_y = 0;
|
||||
|
||||
v_status = wuffs_base__pixel_swizzler__prepare(&self->private_impl.f_swizzler,
|
||||
wuffs_base__pixel_buffer__pixel_format(a_dst),
|
||||
wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024)),
|
||||
wuffs_base__utility__make_pixel_format(self->private_impl.f_pixfmt),
|
||||
wuffs_base__utility__empty_slice_u8(),
|
||||
a_blend);
|
||||
if ( ! wuffs_base__status__is_ok(&v_status)) {
|
||||
return wuffs_private_impl__status__ensure_not_a_suspension(v_status);
|
||||
}
|
||||
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_dst_palette = wuffs_base__pixel_buffer__palette_or_else(a_dst, wuffs_base__make_slice_u8(self->private_data.f_palette, 1024));
|
||||
v_tab = wuffs_base__pixel_buffer__plane(a_dst, 0u);
|
||||
v_src_bytes_per_row = ((uint64_t)((self->private_impl.f_width * 4u)));
|
||||
while (v_src_bytes_per_row <= ((uint64_t)(a_src.len))) {
|
||||
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, v_dst_palette, wuffs_base__slice_u8__subslice_j(a_src, v_src_bytes_per_row));
|
||||
a_src = wuffs_base__slice_u8__subslice_i(a_src, v_src_bytes_per_row);
|
||||
v_y += 1u;
|
||||
}
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
// -------- func webp.decoder.frame_dirty_rect
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
@@ -69866,7 +73619,7 @@ wuffs_webp__decoder__workbuf_len(
|
||||
return wuffs_base__utility__empty_range_ii_u64();
|
||||
}
|
||||
|
||||
return wuffs_base__utility__make_range_ii_u64(0u, 0u);
|
||||
return wuffs_base__utility__make_range_ii_u64(((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])), ((uint64_t)(self->private_impl.f_workbuf_offset_for_transform[3u])));
|
||||
}
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__WEBP)
|
||||
|
||||
Reference in new issue
Block a user