diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 8e5eee9c..7202a7b2 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -8340,13 +8340,13 @@ struct wuffs_png__decoder__struct { uint32_t f_width; uint32_t f_height; uint64_t f_bytes_per_row; - uint64_t f_workbuf_index; + uint64_t f_workbuf_wi; uint64_t f_workbuf_length; uint8_t f_call_sequence; uint8_t f_depth; uint32_t f_src_pixfmt; - uint32_t f_chunk_length; uint32_t f_chunk_type; + uint64_t f_chunk_length; uint64_t f_frame_config_io_position; wuffs_base__pixel_swizzler f_swizzler; @@ -30227,9 +30227,9 @@ wuffs_png__decoder__decode_image_config( while (true) { { WUFFS_BASE__COROUTINE_SUSPENSION_POINT(15); - uint32_t t_9; + uint64_t t_9; if (WUFFS_BASE__LIKELY(io2_a_src - iop_a_src >= 4)) { - t_9 = wuffs_base__load_u32be__no_bounds_check(iop_a_src); + t_9 = ((uint64_t)(wuffs_base__load_u32be__no_bounds_check(iop_a_src))); iop_a_src += 4; } else { self->private_data.s_decode_image_config[0].scratch = 0; @@ -30245,7 +30245,7 @@ wuffs_png__decoder__decode_image_config( *scratch <<= 8; *scratch |= ((uint64_t)(*iop_a_src++)) << (56 - num_bits_9); if (num_bits_9 == 24) { - t_9 = ((uint32_t)(*scratch >> 32)); + t_9 = ((uint64_t)(*scratch >> 32)); break; } num_bits_9 += 8; @@ -30489,6 +30489,9 @@ wuffs_png__decoder__decode_frame( uint8_t* io0_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL; uint8_t* io1_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL; uint8_t* io2_v_w WUFFS_BASE__POTENTIALLY_UNUSED = NULL; + uint64_t v_w_mark = 0; + uint64_t v_r_mark = 0; + wuffs_base__status v_zlib_status = wuffs_base__make_status(NULL); const uint8_t* iop_a_src = NULL; const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL; @@ -30522,9 +30525,9 @@ wuffs_png__decoder__decode_frame( status = wuffs_base__make_status(wuffs_base__note__end_of_data); goto ok; } - self->private_impl.f_workbuf_index = 0; + self->private_impl.f_workbuf_wi = 0; while (true) { - if ((self->private_impl.f_workbuf_index >= self->private_impl.f_workbuf_length) || (self->private_impl.f_workbuf_length >= ((uint64_t)(a_workbuf.len)))) { + if ((self->private_impl.f_workbuf_wi >= self->private_impl.f_workbuf_length) || (self->private_impl.f_workbuf_length >= ((uint64_t)(a_workbuf.len)))) { status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length); goto exit; } @@ -30541,12 +30544,28 @@ wuffs_png__decoder__decode_frame( &io1_v_w, &io2_v_w, wuffs_base__slice_u8__subslice_ij(a_workbuf, - self->private_impl.f_workbuf_index, + self->private_impl.f_workbuf_wi, self->private_impl.f_workbuf_length)); { const uint8_t *o_1_io2_a_src = io2_a_src; wuffs_base__io_reader__limit(&io2_a_src, iop_a_src, - ((uint64_t)(self->private_impl.f_chunk_length))); + self->private_impl.f_chunk_length); + v_w_mark = ((uint64_t)(iop_v_w - io0_v_w)); + v_r_mark = ((uint64_t)(iop_a_src - io0_a_src)); + { + u_w.meta.wi = ((size_t)(iop_v_w - u_w.data.ptr)); + if (a_src) { + a_src->meta.ri = ((size_t)(iop_a_src - a_src->data.ptr)); + } + wuffs_base__status t_0 = wuffs_zlib__decoder__transform_io(&self->private_data.f_zlib, v_w, a_src, wuffs_base__utility__empty_slice_u8()); + v_zlib_status = t_0; + iop_v_w = u_w.data.ptr + u_w.meta.wi; + if (a_src) { + iop_a_src = a_src->data.ptr + a_src->meta.ri; + } + } + wuffs_base__u64__sat_sub_indirect(&self->private_impl.f_chunk_length, wuffs_base__io__count_since(v_r_mark, ((uint64_t)(iop_a_src - io0_a_src)))); + wuffs_base__u64__sat_add_indirect(&self->private_impl.f_workbuf_wi, wuffs_base__io__count_since(v_w_mark, ((uint64_t)(iop_v_w - io0_v_w)))); io2_a_src = o_1_io2_a_src; } v_w = o_0_v_w; @@ -30555,9 +30574,30 @@ wuffs_png__decoder__decode_frame( io1_v_w = o_0_io1_v_w; io2_v_w = o_0_io2_v_w; } - goto label__0__break; + if (wuffs_base__status__is_ok(&v_zlib_status)) { + goto label__0__break; + } else if (v_zlib_status.repr == wuffs_base__suspension__short_write) { + status = wuffs_base__make_status(wuffs_base__error__too_much_data); + goto exit; + } else if (v_zlib_status.repr != wuffs_base__suspension__short_read) { + status = v_zlib_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 (self->private_impl.f_chunk_length == 0) { + } + status = wuffs_base__make_status(wuffs_base__suspension__short_read); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); } label__0__break:; + if (self->private_impl.f_workbuf_wi != self->private_impl.f_workbuf_length) { + status = wuffs_base__make_status(wuffs_base__error__not_enough_data); + goto exit; + } self->private_impl.f_call_sequence = 255; goto ok; diff --git a/std/png/decode_png.wuffs b/std/png/decode_png.wuffs index 7ce1a9af..3e9fcb66 100644 --- a/std/png/decode_png.wuffs +++ b/std/png/decode_png.wuffs @@ -29,7 +29,7 @@ pub struct decoder? implements base.image_decoder( // bytes_per_row doesn't include the 1 byte for the per-row filter. bytes_per_row : base.u64[..= 0x07FF_FFF8], - workbuf_index : base.u64, + workbuf_wi : base.u64, workbuf_length : base.u64[..= 0x0007_FFFF_F100_0007], // Call sequence states: @@ -63,8 +63,8 @@ pub struct decoder? implements base.image_decoder( src_pixfmt : base.u32, - chunk_length : base.u32, chunk_type : base.u32, + chunk_length : base.u64, frame_config_io_position : base.u64, @@ -171,12 +171,12 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_ // Read up until an IDAT chunk. while true { - this.chunk_length = args.src.read_u32be?() + this.chunk_length = args.src.read_u32be_as_u64?() this.chunk_type = args.src.read_u32le?() if this.chunk_type == 'IDAT'le { break } - args.src.skip_u32?(n: this.chunk_length) + args.src.skip?(n: this.chunk_length) // TODO: verify CRC-32 checksum. args.src.skip_u32?(n: 4) } endwhile @@ -229,7 +229,10 @@ pub func decoder.decode_frame_config?(dst: nptr base.frame_config, src: base.io_ } pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, blend: base.pixel_blend, workbuf: slice base.u8, opts: nptr base.decode_frame_options) { - var w : base.io_writer + var w : base.io_writer + var w_mark : base.u64 + var r_mark : base.u64 + var zlib_status : base.status if this.call_sequence < 4 { this.decode_frame_config?(dst: nullptr, src: args.src) @@ -239,19 +242,39 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader, return base."@end of data" } - this.workbuf_index = 0 + this.workbuf_wi = 0 while true { - if (this.workbuf_index >= this.workbuf_length) or ( + if (this.workbuf_wi >= this.workbuf_length) or ( this.workbuf_length >= args.workbuf.length()) { return base."#bad workbuf length" } - io_bind (io: w, data: args.workbuf[this.workbuf_index .. this.workbuf_length]) { - io_limit (io: args.src, limit: this.chunk_length as base.u64) { + io_bind (io: w, data: args.workbuf[this.workbuf_wi .. this.workbuf_length]) { + io_limit (io: args.src, limit: this.chunk_length) { + w_mark = w.mark() + r_mark = args.src.mark() + zlib_status =? this.zlib.transform_io?( + dst: w, src: args.src, workbuf: this.util.empty_slice_u8()) + this.chunk_length ~sat-= args.src.count_since(mark: r_mark) + this.workbuf_wi ~sat+= w.count_since(mark: w_mark) } } - break + + if zlib_status.is_ok() { + break + } else if zlib_status == base."$short write" { + return base."#too much data" + } else if zlib_status <> base."$short read" { + return zlib_status + } else if this.chunk_length == 0 { + // TODO: move to the next IDAT. + } + yield? base."$short read" } endwhile + if this.workbuf_wi <> this.workbuf_length { + return base."#not enough data" + } + this.call_sequence = 0xFF }