From ad80d8e7fc6ba033bec75b725f74de917c91756c Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 2 Sep 2018 15:09:05 +1000 Subject: [PATCH] wuffs gen -version=0.2.0-alpha.16 --- release/c/wuffs-v0.2.h | 141 +++++++++++++++++++++++++++++------------ 1 file changed, 100 insertions(+), 41 deletions(-) diff --git a/release/c/wuffs-v0.2.h b/release/c/wuffs-v0.2.h index bc167fba..98279b60 100644 --- a/release/c/wuffs-v0.2.h +++ b/release/c/wuffs-v0.2.h @@ -65,14 +65,14 @@ extern "C" { // work-in-progress version, not a release version, and has no backwards or // forwards compatibility guarantees. // -// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-08-26 UTC, -// based on revision a34cc5311e880ade6c4be697bb07170c0685d654. +// WUFFS_VERSION was overridden by "wuffs gen -version" on 2018-09-02 UTC, +// based on revision 555a72d7a9e0fa3a2ecc810b2af820252f9c4fdf. #define WUFFS_VERSION ((uint64_t)0x0000000000020000) #define WUFFS_VERSION_MAJOR ((uint64_t)0x00000000) #define WUFFS_VERSION_MINOR ((uint64_t)0x0002) #define WUFFS_VERSION_PATCH ((uint64_t)0x0000) -#define WUFFS_VERSION_EXTENSION "alpha.15" -#define WUFFS_VERSION_STRING "0.2.0-alpha.15" +#define WUFFS_VERSION_EXTENSION "alpha.16" +#define WUFFS_VERSION_STRING "0.2.0-alpha.16" // Define WUFFS_CONFIG__STATIC_FUNCTIONS to make all of Wuffs' functions have // static storage. The motivation is discussed in the "ALLOW STATIC @@ -140,7 +140,9 @@ extern const char* wuffs_base__error__bad_argument_length_too_short; extern const char* wuffs_base__error__bad_argument; extern const char* wuffs_base__error__bad_call_sequence; extern const char* wuffs_base__error__bad_receiver; +extern const char* wuffs_base__error__bad_restart; extern const char* wuffs_base__error__bad_sizeof_receiver; +extern const char* wuffs_base__error__bad_work_buffer_length; extern const char* wuffs_base__error__bad_wuffs_version; extern const char* wuffs_base__error__cannot_return_a_suspension; extern const char* wuffs_base__error__check_wuffs_version_not_applicable; @@ -1550,6 +1552,7 @@ typedef struct { // Do not access the private_impl's fields directly. There is no API/ABI // compatibility or safety guarantee if you do so. struct { + wuffs_base__range_ii_u64 work_buffer_size; uint32_t num_loops; bool first_frame_is_opaque; } private_impl; @@ -1559,10 +1562,13 @@ typedef struct { wuffs_base__pixel_subsampling pixsub, uint32_t width, uint32_t height, + uint64_t work_buffer_size0, + uint64_t work_buffer_size1, uint32_t num_loops, bool first_frame_is_opaque); inline void invalidate(); inline bool is_valid(); + inline wuffs_base__range_ii_u64 work_buffer_size(); inline uint32_t num_loops(); inline uint32_t first_frame_is_opaque(); #endif // __cplusplus @@ -1576,6 +1582,8 @@ wuffs_base__image_config__initialize(wuffs_base__image_config* c, wuffs_base__pixel_subsampling pixsub, uint32_t width, uint32_t height, + uint64_t work_buffer_size0, + uint64_t work_buffer_size1, uint32_t num_loops, bool first_frame_is_opaque) { if (!c) { @@ -1586,6 +1594,8 @@ wuffs_base__image_config__initialize(wuffs_base__image_config* c, c->pixcfg.private_impl.pixsub = pixsub; c->pixcfg.private_impl.width = width; c->pixcfg.private_impl.height = height; + c->private_impl.work_buffer_size.min_incl = work_buffer_size0; + c->private_impl.work_buffer_size.max_incl = work_buffer_size1; c->private_impl.num_loops = num_loops; c->private_impl.first_frame_is_opaque = first_frame_is_opaque; return; @@ -1605,6 +1615,11 @@ wuffs_base__image_config__is_valid(wuffs_base__image_config* c) { return c && wuffs_base__pixel_config__is_valid(&(c->pixcfg)); } +static inline wuffs_base__range_ii_u64 // +wuffs_base__image_config__work_buffer_size(wuffs_base__image_config* c) { + return c ? c->private_impl.work_buffer_size : ((wuffs_base__range_ii_u64){}); +} + static inline uint32_t // wuffs_base__image_config__num_loops(wuffs_base__image_config* c) { return c ? c->private_impl.num_loops : 0; @@ -1622,9 +1637,12 @@ wuffs_base__image_config::initialize(wuffs_base__pixel_format pixfmt, wuffs_base__pixel_subsampling pixsub, uint32_t width, uint32_t height, + uint64_t work_buffer_size0, + uint64_t work_buffer_size1, uint32_t num_loops, bool first_frame_is_opaque) { wuffs_base__image_config__initialize(this, pixfmt, pixsub, width, height, + work_buffer_size0, work_buffer_size1, num_loops, first_frame_is_opaque); } @@ -1638,6 +1656,11 @@ wuffs_base__image_config::is_valid() { return wuffs_base__image_config__is_valid(this); } +inline wuffs_base__range_ii_u64 // +wuffs_base__image_config::work_buffer_size() { + return wuffs_base__image_config__work_buffer_size(this); +} + inline uint32_t // wuffs_base__image_config::num_loops() { return wuffs_base__image_config__num_loops(this); @@ -1945,6 +1968,24 @@ wuffs_base__pixel_buffer::palette() { #endif // __cplusplus +// -------- + +typedef struct { + // Do not access the private_impl's fields directly. There is no API/ABI + // compatibility or safety guarantee if you do so. + struct { + uint8_t TODO; + } private_impl; + +#ifdef __cplusplus +#endif // __cplusplus + +} wuffs_base__decode_frame_options; + +#ifdef __cplusplus + +#endif // __cplusplus + #ifdef __cplusplus } // extern "C" #endif @@ -2408,6 +2449,7 @@ typedef struct { uint32_t f_height; uint8_t f_call_sequence; bool f_end_of_data; + bool f_restarted; bool f_previous_lzw_decode_ended_abruptly; uint8_t f_which_palette; uint8_t f_interlace; @@ -2517,14 +2559,15 @@ typedef struct { inline uint64_t num_decoded_frame_configs(); inline uint64_t num_decoded_frames(); inline wuffs_base__range_ii_u64 work_buffer_size(); - inline wuffs_base__status reset_before(wuffs_base__frame_config* a_fc); + inline wuffs_base__status restart_frame(uint64_t a_index, + uint64_t a_io_position); inline wuffs_base__status decode_frame_config(wuffs_base__frame_config* a_dst, wuffs_base__io_reader a_src); - inline wuffs_base__status decode_frame(wuffs_base__pixel_buffer* a_dst, - uint32_t a_pixbuf_origin_x, - uint32_t a_pixbuf_origin_y, - wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_work_buffer); + inline wuffs_base__status decode_frame( + wuffs_base__pixel_buffer* a_dst, + wuffs_base__io_reader a_src, + wuffs_base__slice_u8 a_work_buffer, + wuffs_base__decode_frame_options* a_opts); #endif // __cplusplus } wuffs_gif__decoder; @@ -2558,8 +2601,9 @@ WUFFS_BASE__MAYBE_STATIC wuffs_base__range_ii_u64 // wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self); WUFFS_BASE__MAYBE_STATIC wuffs_base__status // -wuffs_gif__decoder__reset_before(wuffs_gif__decoder* self, - wuffs_base__frame_config* a_fc); +wuffs_gif__decoder__restart_frame(wuffs_gif__decoder* self, + uint64_t a_index, + uint64_t a_io_position); WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self, @@ -2569,10 +2613,9 @@ wuffs_gif__decoder__decode_frame_config(wuffs_gif__decoder* self, WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, wuffs_base__pixel_buffer* a_dst, - uint32_t a_pixbuf_origin_x, - uint32_t a_pixbuf_origin_y, wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_work_buffer); + wuffs_base__slice_u8 a_work_buffer, + wuffs_base__decode_frame_options* a_opts); // ---------------- C++ Convenience Methods @@ -2607,8 +2650,8 @@ wuffs_gif__decoder::work_buffer_size() { } inline wuffs_base__status // -wuffs_gif__decoder::reset_before(wuffs_base__frame_config* a_fc) { - return wuffs_gif__decoder__reset_before(this, a_fc); +wuffs_gif__decoder::restart_frame(uint64_t a_index, uint64_t a_io_position) { + return wuffs_gif__decoder__restart_frame(this, a_index, a_io_position); } inline wuffs_base__status // @@ -2619,12 +2662,11 @@ wuffs_gif__decoder::decode_frame_config(wuffs_base__frame_config* a_dst, inline wuffs_base__status // wuffs_gif__decoder::decode_frame(wuffs_base__pixel_buffer* a_dst, - uint32_t a_pixbuf_origin_x, - uint32_t a_pixbuf_origin_y, wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_work_buffer) { - return wuffs_gif__decoder__decode_frame( - this, a_dst, a_pixbuf_origin_x, a_pixbuf_origin_y, a_src, a_work_buffer); + wuffs_base__slice_u8 a_work_buffer, + wuffs_base__decode_frame_options* a_opts) { + return wuffs_gif__decoder__decode_frame(this, a_dst, a_src, a_work_buffer, + a_opts); } #endif // __cplusplus @@ -3610,8 +3652,11 @@ const char* wuffs_base__error__bad_argument_length_too_short = const char* wuffs_base__error__bad_argument = "?base: bad argument"; const char* wuffs_base__error__bad_call_sequence = "?base: bad call sequence"; const char* wuffs_base__error__bad_receiver = "?base: bad receiver"; +const char* wuffs_base__error__bad_restart = "?base: bad restart"; const char* wuffs_base__error__bad_sizeof_receiver = "?base: bad sizeof receiver"; +const char* wuffs_base__error__bad_work_buffer_length = + "?base: bad work buffer length"; const char* wuffs_base__error__bad_wuffs_version = "?base: bad wuffs version"; const char* wuffs_base__error__cannot_return_a_suspension = "?base: cannot return a suspension"; @@ -6397,7 +6442,8 @@ wuffs_gif__decoder__decode_image_config(wuffs_gif__decoder* self, if (a_dst != NULL) { wuffs_base__image_config__initialize( a_dst, 570984584, 0, self->private_impl.f_width, - self->private_impl.f_height, v_num_loops, v_ffio); + self->private_impl.f_height, ((uint64_t)(self->private_impl.f_width)), + ((uint64_t)(self->private_impl.f_width)), v_num_loops, v_ffio); } self->private_impl.f_call_sequence = 1; @@ -6464,11 +6510,12 @@ wuffs_gif__decoder__work_buffer_size(wuffs_gif__decoder* self) { 0); } -// -------- func gif.decoder.reset_before +// -------- func gif.decoder.restart_frame WUFFS_BASE__MAYBE_STATIC wuffs_base__status // -wuffs_gif__decoder__reset_before(wuffs_gif__decoder* self, - wuffs_base__frame_config* a_fc) { +wuffs_gif__decoder__restart_frame(wuffs_gif__decoder* self, + uint64_t a_index, + uint64_t a_io_position) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -6477,10 +6524,6 @@ wuffs_gif__decoder__reset_before(wuffs_gif__decoder* self, ? wuffs_base__error__disabled_by_previous_error : wuffs_base__error__check_wuffs_version_missing; } - if (!a_fc) { - self->private_impl.magic = WUFFS_BASE__DISABLED; - return wuffs_base__error__bad_argument; - } wuffs_base__status status = NULL; if (self->private_impl.f_call_sequence == 0) { @@ -6488,10 +6531,10 @@ wuffs_gif__decoder__reset_before(wuffs_gif__decoder* self, goto exit; } self->private_impl.f_end_of_data = false; - self->private_impl.f_num_decoded_frame_configs_value = - wuffs_base__frame_config__index(a_fc); - self->private_impl.f_num_decoded_frames_value = - self->private_impl.f_num_decoded_frame_configs_value; + self->private_impl.f_restarted = true; + self->private_impl.f_frame_config_io_position = a_io_position; + self->private_impl.f_num_decoded_frame_configs_value = a_index; + self->private_impl.f_num_decoded_frames_value = a_index; wuffs_gif__decoder__reset_gc(self); goto exit; exit: @@ -6702,10 +6745,9 @@ exit: WUFFS_BASE__MAYBE_STATIC wuffs_base__status // wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, wuffs_base__pixel_buffer* a_dst, - uint32_t a_pixbuf_origin_x, - uint32_t a_pixbuf_origin_y, wuffs_base__io_reader a_src, - wuffs_base__slice_u8 a_work_buffer) { + wuffs_base__slice_u8 a_work_buffer, + wuffs_base__decode_frame_options* a_opts) { if (!self) { return wuffs_base__error__bad_receiver; } @@ -6728,6 +6770,11 @@ wuffs_gif__decoder__decode_frame(wuffs_gif__decoder* self, switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; + if (((uint64_t)(a_work_buffer.len)) != + ((uint64_t)(self->private_impl.f_width))) { + status = wuffs_base__error__bad_work_buffer_length; + goto exit; + } if (self->private_impl.f_call_sequence != 2) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1); status = wuffs_gif__decoder__decode_frame_config(self, NULL, a_src); @@ -6808,11 +6855,23 @@ wuffs_gif__decoder__decode_up_to_id_part1(wuffs_gif__decoder* self, switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; - self->private_impl.f_frame_config_io_position = - (a_src.private_impl.buf - ? wuffs_base__u64__sat_add(a_src.private_impl.buf->pos, + if (!self->private_impl.f_restarted) { + self->private_impl.f_frame_config_io_position = + (a_src.private_impl.buf ? wuffs_base__u64__sat_add( + a_src.private_impl.buf->pos, iop_a_src - a_src.private_impl.buf->ptr) - : 0); + : 0); + } else if (self->private_impl.f_frame_config_io_position != + (a_src.private_impl.buf + ? wuffs_base__u64__sat_add( + a_src.private_impl.buf->pos, + iop_a_src - a_src.private_impl.buf->ptr) + : 0)) { + status = wuffs_base__error__bad_restart; + goto exit; + } else { + self->private_impl.f_restarted = false; + } while (true) { { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(1);