From 3df370e82c7b02716031aa29389ac94d861c384f Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Mon, 28 May 2018 09:20:43 +1000 Subject: [PATCH] Fill more of std/gif's copy_to_image_buffer --- gen/c/std/gif.c | 59 +++++++++++++++++++++++++++++++++++----- lang/check/bounds.go | 23 ++++++++-------- std/gif/decode_gif.wuffs | 53 ++++++++++++++++++++++++++++++------ 3 files changed, 109 insertions(+), 26 deletions(-) diff --git a/gen/c/std/gif.c b/gen/c/std/gif.c index 127933ff..e302f141 100644 --- a/gen/c/std/gif.c +++ b/gen/c/std/gif.c @@ -3634,23 +3634,68 @@ static wuffs_gif__status wuffs_gif__decoder__copy_to_image_buffer( wuffs_base__slice_u8 v_dst; wuffs_base__slice_u8 v_src; - wuffs_base__table_u8 v_tab; uint32_t v_n; uint32_t v_new_ri; + wuffs_base__table_u8 v_tab; + uint64_t v_i; v_dst = ((wuffs_base__slice_u8){}); v_src = ((wuffs_base__slice_u8){}); + v_n = 0; + v_new_ri = 0; v_tab = wuffs_base__image_buffer__plane(a_ib, 0); if (!self->private_impl.f_interlace && - (((uint64_t)(v_tab.width)) == ((uint64_t)(v_tab.stride)))) { + (((uint64_t)(v_tab.width)) == ((uint64_t)(v_tab.stride))) && + (self->private_impl.f_dst_x0 == 0) && + (((uint64_t)(self->private_impl.f_dst_x1)) == + ((uint64_t)(v_tab.width))) && + (((uint64_t)(self->private_impl.f_dst_y1)) <= + ((uint64_t)(v_tab.height)))) { + if (self->private_impl.f_uncompressed_ri > + self->private_impl.f_uncompressed_wi) { + status = WUFFS_GIF__ERROR_INTERNAL_ERROR_INCONSISTENT_RI_WI; + goto exit; + } + v_src = wuffs_base__slice_u8__subslice_ij( + ((wuffs_base__slice_u8){.ptr = self->private_impl.f_uncompressed, + .len = 4096}), + self->private_impl.f_uncompressed_ri, + self->private_impl.f_uncompressed_wi); + if (self->private_impl.f_dst_y >= self->private_impl.f_dst_y1) { + status = WUFFS_GIF__ERROR_TOO_MUCH_PIXEL_DATA; + goto exit; + } + v_i = 0; v_dst = wuffs_base__table_u8__linearize(v_tab); - if (((uint64_t)(v_dst.len)) == 0) { + v_i = (((uint64_t)(self->private_impl.f_dst_y1)) * + ((uint64_t)(self->private_impl.f_dst_x1))); + if (v_i < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_j(v_dst, v_i); + } + v_i = ((((uint64_t)(self->private_impl.f_dst_y)) * + ((uint64_t)(self->private_impl.f_dst_x1))) + + ((uint64_t)(self->private_impl.f_dst_x))); + if (v_i < ((uint64_t)(v_dst.len))) { + v_dst = wuffs_base__slice_u8__subslice_i(v_dst, v_i); + v_n = ((uint32_t)( + (wuffs_base__slice_u8__copy_from_slice(v_dst, v_src) & 4294967295))); + v_new_ri = + wuffs_base__u32__sat_add(self->private_impl.f_uncompressed_ri, v_n); + self->private_impl.f_uncompressed_ri = + wuffs_base__u32__min(v_new_ri, 4096); + wuffs_base__u64__sat_add_indirect(&v_i, ((uint64_t)(v_n))); + if (((uint64_t)(v_tab.width)) <= 0) { + status = WUFFS_GIF__ERROR_TOO_MUCH_PIXEL_DATA; + goto exit; + } + self->private_impl.f_dst_x = + ((uint32_t)(((v_i % ((uint64_t)(v_tab.width))) & 4294967295))); + self->private_impl.f_dst_y = + ((uint32_t)(((v_i / ((uint64_t)(v_tab.width))) & 4294967295))); } status = WUFFS_GIF__STATUS_OK; goto ok; } - v_n = 0; - v_new_ri = 0; label_0_continue:; while (self->private_impl.f_uncompressed_wi > self->private_impl.f_uncompressed_ri) { @@ -3673,7 +3718,7 @@ label_0_continue:; v_n = ((uint32_t)( (wuffs_base__slice_u8__copy_from_slice(v_dst, v_src) & 4294967295))); v_new_ri = - wuffs_base__u32__sat_add(v_n, self->private_impl.f_uncompressed_ri); + wuffs_base__u32__sat_add(self->private_impl.f_uncompressed_ri, v_n); self->private_impl.f_uncompressed_ri = wuffs_base__u32__min(v_new_ri, 4096); wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_n); @@ -3692,7 +3737,7 @@ label_0_continue:; v_n = wuffs_base__u32__min(v_n, (self->private_impl.f_uncompressed_wi - self->private_impl.f_uncompressed_ri)); v_new_ri = - wuffs_base__u32__sat_add(v_n, self->private_impl.f_uncompressed_ri); + wuffs_base__u32__sat_add(self->private_impl.f_uncompressed_ri, v_n); self->private_impl.f_uncompressed_ri = wuffs_base__u32__min(v_new_ri, 4096); wuffs_base__u32__sat_add_indirect(&self->private_impl.f_dst_x, v_n); if (self->private_impl.f_dst_x1 <= self->private_impl.f_dst_x) { diff --git a/lang/check/bounds.go b/lang/check/bounds.go index e3ace9de..3b1528e1 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -1084,8 +1084,18 @@ func (q *checker) bcheckExprBinaryOp1(op t.ID, lhs *a.Expr, lMin *big.Int, lMax } return big.NewInt(0).Mul(lMin, rMin), big.NewInt(0).Mul(lMax, rMax), nil - case t.IDXBinarySlash: - // TODO. + case t.IDXBinarySlash, t.IDXBinaryPercent: + // Prohibit division by zero. + if lMin.Sign() < 0 { + return nil, nil, fmt.Errorf("check: divide/modulus op argument %q is possibly negative", lhs.Str(q.tm)) + } + if rMin.Sign() <= 0 { + return nil, nil, fmt.Errorf("check: divide/modulus op argument %q is possibly non-positive", rhs.Str(q.tm)) + } + if op == t.IDXBinarySlash { + return big.NewInt(0).Mul(lMin, rMax), big.NewInt(0).Mul(lMax, rMin), nil + } + return zero, big.NewInt(0).Sub(rMax, one), nil case t.IDXBinaryShiftL: if lMin.Sign() < 0 { @@ -1141,15 +1151,6 @@ func (q *checker) bcheckExprBinaryOp1(op t.ID, lhs *a.Expr, lMin *big.Int, lMax // conservative, but works fine in practice. return zero, bitMask(z.BitLen()), nil - case t.IDXBinaryPercent: - if lMin.Sign() < 0 { - return nil, nil, fmt.Errorf("check: modulus op argument %q is possibly negative", lhs.Str(q.tm)) - } - if rMin.Sign() <= 0 { - return nil, nil, fmt.Errorf("check: modulus op argument %q is possibly non-positive", rhs.Str(q.tm)) - } - return zero, big.NewInt(0).Sub(rMax, one), nil - case t.IDXBinaryTildeModPlus, t.IDXBinaryTildeModMinus: typ := lhs.MType() if typ.IsIdeal() { diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index a7d51c89..b17021b7 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -513,19 +513,56 @@ pri func decoder.copy_to_image_buffer?(ib ptr base.image_buffer)() { // TODO: don't assume a packed pixel format. var dst slice base.u8 var src slice base.u8 + var n base.u32 + // TODO: we shouldn't need this temporary variable. + var new_ri base.u32 var tab table base.u8 = in.ib.plane(p:0) - if (not this.interlace) and (tab.width() == tab.stride()) { + + // As an optimization, linearize tab's rows into one big slice, in order to + // make fewer copy_from_slice calls. + // + // TODO: measure this optimization and delete it if it doesn't help. + if (not this.interlace) and (tab.width() == tab.stride()) and (this.dst_x0 == 0) and + ((this.dst_x1 as base.u64) == tab.width()) and + ((this.dst_y1 as base.u64) <= tab.height()) { + + if this.uncompressed_ri > this.uncompressed_wi { + return error "internal error: inconsistent ri/wi" + } + src = this.uncompressed[this.uncompressed_ri:this.uncompressed_wi] + + if this.dst_y >= this.dst_y1 { + return error "too much pixel data" + } + + var i base.u64 dst = tab.linearize() - if dst.length() == 0 { - // TODO. + + i = ((this.dst_y1 as base.u64) * (this.dst_x1 as base.u64)) + if i < dst.length() { + dst = dst[:i] + } + + i = ((this.dst_y as base.u64) * (this.dst_x1 as base.u64)) + (this.dst_x as base.u64) + if i < dst.length() { + dst = dst[i:] + n = (dst.copy_from_slice(s:src) & 0xFFFFFFFF) as base.u32 + + new_ri = this.uncompressed_ri ~sat+ n + this.uncompressed_ri = new_ri.min(x:4096) + + i ~sat+= n as base.u64 + + if tab.width() <= 0 { + return error "too much pixel data" + } + this.dst_x = ((i % tab.width()) & 0xFFFFFFFF) as base.u32 + this.dst_y = ((i / tab.width()) & 0xFFFFFFFF) as base.u32 } return } - var n base.u32 - // TODO: we shouldn't need this temporary variable. - var new_ri base.u32 while this.uncompressed_wi > this.uncompressed_ri { assert this.uncompressed_ri < this.uncompressed_wi via "a < b: b > a"() src = this.uncompressed[this.uncompressed_ri:this.uncompressed_wi] @@ -549,7 +586,7 @@ pri func decoder.copy_to_image_buffer?(ib ptr base.image_buffer)() { dst = dst[this.dst_x as base.u64:] n = (dst.copy_from_slice(s:src) & 0xFFFFFFFF) as base.u32 - new_ri = n ~sat+ this.uncompressed_ri + new_ri = this.uncompressed_ri ~sat+ n this.uncompressed_ri = new_ri.min(x:4096) this.dst_x ~sat+= n } @@ -571,7 +608,7 @@ pri func decoder.copy_to_image_buffer?(ib ptr base.image_buffer)() { n = this.dst_x1 - this.dst_x n = n.min(x:this.uncompressed_wi - this.uncompressed_ri) - new_ri = n ~sat+ this.uncompressed_ri + new_ri = this.uncompressed_ri ~sat+ n this.uncompressed_ri = new_ri.min(x:4096) this.dst_x ~sat+= n