From 33a4557d98bcf08724ab15dc61a685acab65bc16 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sat, 15 Dec 2018 14:10:10 +1100 Subject: [PATCH] Collect GIF's LZW data into larger batches MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit name old speed new speed delta wuffs_gif_decode_1k_bw/clang 224MB/s ± 1% 227MB/s ± 0% +0.98% (p=0.000 n=10+9) wuffs_gif_decode_1k_color/clang 116MB/s ± 1% 118MB/s ± 1% +2.26% (p=0.000 n=10+10) wuffs_gif_decode_10k_bgra/clang 541MB/s ± 0% 568MB/s ± 1% +4.97% (p=0.000 n=9+10) wuffs_gif_decode_10k_indexed/clang 144MB/s ± 0% 152MB/s ± 0% +5.61% (p=0.000 n=9+10) wuffs_gif_decode_100k_artificial/clang 438MB/s ± 1% 454MB/s ± 1% +3.56% (p=0.000 n=9+10) wuffs_gif_decode_100k_realistic/clang 171MB/s ± 0% 179MB/s ± 0% +4.64% (p=0.000 n=8+10) wuffs_gif_decode_1000k/clang 174MB/s ± 0% 180MB/s ± 0% +3.90% (p=0.000 n=9+10) wuffs_gif_decode_anim_screencap/clang 897MB/s ± 1% 943MB/s ± 0% +5.10% (p=0.000 n=9+9) wuffs_gif_decode_1k_bw/gcc 250MB/s ± 1% 241MB/s ± 1% -3.26% (p=0.000 n=10+10) wuffs_gif_decode_1k_color/gcc 132MB/s ± 1% 130MB/s ± 1% -2.15% (p=0.000 n=10+10) wuffs_gif_decode_10k_bgra/gcc 534MB/s ± 1% 535MB/s ± 1% ~ (p=0.211 n=9+10) wuffs_gif_decode_10k_indexed/gcc 162MB/s ± 1% 163MB/s ± 0% ~ (p=0.105 n=10+10) wuffs_gif_decode_100k_artificial/gcc 460MB/s ± 0% 456MB/s ± 0% -0.80% (p=0.000 n=10+10) wuffs_gif_decode_100k_realistic/gcc 186MB/s ± 0% 186MB/s ± 1% -0.33% (p=0.001 n=9+10) wuffs_gif_decode_1000k/gcc 189MB/s ± 1% 188MB/s ± 1% ~ (p=0.053 n=9+10) wuffs_gif_decode_anim_screencap/gcc 981MB/s ± 1% 971MB/s ± 1% -0.95% (p=0.000 n=10+10) --- cmd/wuffs-c/internal/cgen/base/io-private.h | 46 +++- cmd/wuffs-c/internal/cgen/builtin.go | 22 +- cmd/wuffs-c/internal/cgen/data.go | 7 +- cmd/wuffs-c/internal/cgen/var.go | 18 +- lang/builtin/builtin.go | 1 + lang/token/list.go | 40 +-- release/c/wuffs-unsupported-snapshot.h | 263 ++++++++++++++------ std/gif/decode_gif.wuffs | 83 +++--- std/lzw/decode_lzw.wuffs | 3 +- 9 files changed, 325 insertions(+), 158 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/base/io-private.h b/cmd/wuffs-c/internal/cgen/base/io-private.h index 46173d6b..348a2103 100644 --- a/cmd/wuffs-c/internal/cgen/base/io-private.h +++ b/cmd/wuffs-c/internal/cgen/base/io-private.h @@ -188,6 +188,26 @@ wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w, return n; } +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set(wuffs_base__io_reader* o, + wuffs_base__io_buffer* b, + uint8_t** ptr_iop, + uint8_t** ptr_io1, + wuffs_base__slice_u8 data) { + b->data = data; + b->meta.wi = data.len; + b->meta.ri = 0; + b->meta.pos = 0; + b->meta.closed = false; + + o->private_impl.buf = b; + o->private_impl.mark = data.ptr; + o->private_impl.limit = data.ptr + data.len; + *ptr_iop = data.ptr; + *ptr_io1 = data.ptr + data.len; + return ((wuffs_base__empty_struct){}); +} + static inline wuffs_base__empty_struct // wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, uint8_t* ioptr_r, @@ -204,24 +224,36 @@ wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { return ((wuffs_base__empty_struct){}); } +static inline wuffs_base__slice_u8 // +wuffs_base__io_reader__take(uint8_t** ptr_iop, uint8_t* io1, uint64_t n) { + if (n <= (io1 - *ptr_iop)) { + uint8_t* p = *ptr_iop; + *ptr_iop += n; + return ((wuffs_base__slice_u8){ + .ptr = p, + .len = n, + }); + } + return ((wuffs_base__slice_u8){}); +} + static inline wuffs_base__empty_struct // wuffs_base__io_writer__set(wuffs_base__io_writer* o, wuffs_base__io_buffer* b, uint8_t** ioptr1_ptr, uint8_t** ioptr2_ptr, - wuffs_base__slice_u8 s) { - b->data.ptr = s.ptr; - b->data.len = s.len; + wuffs_base__slice_u8 data) { + b->data = data; b->meta.wi = 0; b->meta.ri = 0; b->meta.pos = 0; b->meta.closed = false; o->private_impl.buf = b; - o->private_impl.mark = s.ptr; - o->private_impl.limit = s.ptr + s.len; - *ioptr1_ptr = s.ptr; - *ioptr2_ptr = s.ptr + s.len; + o->private_impl.mark = data.ptr; + o->private_impl.limit = data.ptr + data.len; + *ioptr1_ptr = data.ptr; + *ioptr2_ptr = data.ptr + data.len; return ((wuffs_base__empty_struct){}); } diff --git a/cmd/wuffs-c/internal/cgen/builtin.go b/cmd/wuffs-c/internal/cgen/builtin.go index d81b8818..01de0d25 100644 --- a/cmd/wuffs-c/internal/cgen/builtin.go +++ b/cmd/wuffs-c/internal/cgen/builtin.go @@ -104,12 +104,11 @@ func (g *gen) writeBuiltinIO(b *buffer, recv *a.Expr, method t.ID, args []*a.Nod return nil case t.IDSet: - typ := "reader" + typ, v := "reader", "r" if len(args) == 1 { - typ = "writer" + typ, v = "writer", "w" } - // TODO: don't hard-code v_w and u_w. - b.printf("wuffs_base__io_%s__set(&v_w, &u_w, &iop_v_w, &io1_v_w,", typ) + b.printf("wuffs_base__io_%s__set(&v_%s, &u_%s, &iop_v_%s, &io1_v_%s,", typ, v, v, v, v) return g.writeArgs(b, args, depth) } @@ -142,13 +141,18 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args [] return nil case t.IDSinceMark, t.IDSinceMarkLength: + prefix, name := aPrefix, "src" + if recv.Operator() == 0 { + prefix, name = vPrefix, recv.Ident().Str(g.tm) + } + if method == t.IDSinceMark { b.printf("((wuffs_base__slice_u8){ "+ - ".ptr = %ssrc.private_impl.mark, "+ + ".ptr = %s%s.private_impl.mark, "+ ".len = (size_t)(", - aPrefix) + prefix, name) } - b.printf("iop_a_src - %ssrc.private_impl.mark", aPrefix) + b.printf("iop_%s%s - %s%s.private_impl.mark", prefix, name, prefix, name) if method == t.IDSinceMark { b.writes("), })") } @@ -165,6 +169,10 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args [] } b.writes(", wuffs_base__return_empty_struct())") return nil + + case t.IDTake: + b.printf("wuffs_base__io_reader__take(&iop_a_src, io1_a_src,") + return g.writeArgs(b, args, depth) } if method >= peekMethodsBase { diff --git a/cmd/wuffs-c/internal/cgen/data.go b/cmd/wuffs-c/internal/cgen/data.go index 8b2a11b3..42cba951 100644 --- a/cmd/wuffs-c/internal/cgen/data.go +++ b/cmd/wuffs-c/internal/cgen/data.go @@ -151,9 +151,10 @@ const baseIOPrivateH = "" + "t8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n if (!distance) {\n return 0;\n }\n uint8_t* ptr = *ptr_ptr;\n if ((size_t)(ptr - start) < (size_t)(distance)) {\n return 0;\n }\n start = ptr - distance;\n size_t n = end - ptr;\n if ((size_t)(length) > n) {\n length = n;\n } else {\n n = length;\n }\n // TODO: unrolling by 3 seems best for the std/deflate benchmarks, but that\n // is mostly because 3 is the minimum length for the deflate format. This\n // function implementation shouldn't overfit to that one format. Perhaps the\n // copy_n_from_history Wuffs method should also take an unroll hint argument,\n // and the cgen can look if that argument is the constant expression '3'.\n //\n // See also wuffs_base__io_writer__copy_n_from_history_fast below.\n //\n // Alternatively, or additionally, ha" + "ve a sloppy_copy_n_from_history method\n // that copies 8 bytes at a time, possibly writing more than length bytes?\n for (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\n// wuffs_base__io_writer__copy_n_from_history_fast is like the\n// wuffs_base__io_writer__copy_n_from_history function above, but has stronger\n// pre-conditions. The caller needs to prove that:\n// - distance > 0\n// - distance <= (*ptr_ptr - start)\n// - length <= (end - *ptr_ptr)\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_history_fast(uint8_t** ptr_ptr,\n uint8_t* start,\n uint8_t* end,\n uint32_t length,\n uint32_t distance) {\n uint8_t* ptr = *ptr_ptr;\n start = ptr - distance;\n uint32_t n = length;\n fo" + "r (; n >= 3; n -= 3) {\n *ptr++ = *start++;\n *ptr++ = *start++;\n *ptr++ = *start++;\n }\n for (; n; n--) {\n *ptr++ = *start++;\n }\n *ptr_ptr = ptr;\n return length;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_reader(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n uint8_t** ptr_ioptr_r,\n uint8_t* iobounds1_r) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = length;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n uint8_t* ioptr_r = *ptr_ioptr_r;\n if (n > ((size_t)(iobounds1_r - ioptr_r))) {\n n = iobounds1_r - ioptr_r;\n }\n if (n > 0) {\n memmove(ioptr_w, ioptr_r, n);\n *ptr_ioptr_w += n;\n *ptr_ioptr_r += n;\n }\n return n;\n}\n\nstatic inline uint64_t //\nwuffs_base__io_writer__copy_from_slice(uint8_t** ptr_ioptr_w,\n u" + - "int8_t* iobounds1_w,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* ioptr_r,\n " + - " uint64_t limit) {\n if (o && (((size_t)(o->private_impl.limit - ioptr_r)) > limit)) {\n o->private_impl.limit = ioptr_r + limit;\n }\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n wuffs_base__io_buffer* b,\n uint8_t** ioptr1_ptr,\n uint8_t** ioptr2_ptr,\n wuffs_base__slice_u8 s) {\n b->data.ptr = s.ptr;\n b->data.len = s.len;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = s.ptr;\n o->private_impl.limit = s.ptr + s.len;\n *ioptr1_ptr = s.ptr;\n *ioptr2_ptr = s.ptr + s.len;\n return ((wuffs_base__empty_struct){})" + - ";\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer* o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" + + "int8_t* iobounds1_w,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline uint32_t //\nwuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w,\n uint8_t* iobounds1_w,\n uint32_t length,\n wuffs_base__slice_u8 src) {\n uint8_t* ioptr_w = *ptr_ioptr_w;\n size_t n = src.len;\n if (n > length) {\n n = length;\n }\n if (n > ((size_t)(iobounds1_w - ioptr_w))) {\n n = iobounds1_w - ioptr_w;\n }\n if (n > 0) {\n memmove(ioptr_w, src.ptr, n);\n *ptr_ioptr_w += n;\n }\n return n;\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set(wuffs_base__io_reader* o,\n wuffs_base__io_buffer* b,\n " + + " uint8_t** ptr_iop,\n uint8_t** ptr_io1,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = data.len;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = data.ptr;\n o->private_impl.limit = data.ptr + data.len;\n *ptr_iop = data.ptr;\n *ptr_io1 = data.ptr + data.len;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_limit(wuffs_base__io_reader* o,\n uint8_t* ioptr_r,\n uint64_t limit) {\n if (o && (((size_t)(o->private_impl.limit - ioptr_r)) > limit)) {\n o->private_impl.limit = ioptr_r + limit;\n }\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic " + + "inline wuffs_base__slice_u8 //\nwuffs_base__io_reader__take(uint8_t** ptr_iop, uint8_t* io1, uint64_t n) {\n if (n <= (io1 - *ptr_iop)) {\n uint8_t* p = *ptr_iop;\n *ptr_iop += n;\n return ((wuffs_base__slice_u8){\n .ptr = p,\n .len = n,\n });\n }\n return ((wuffs_base__slice_u8){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set(wuffs_base__io_writer* o,\n wuffs_base__io_buffer* b,\n uint8_t** ioptr1_ptr,\n uint8_t** ioptr2_ptr,\n wuffs_base__slice_u8 data) {\n b->data = data;\n b->meta.wi = 0;\n b->meta.ri = 0;\n b->meta.pos = 0;\n b->meta.closed = false;\n\n o->private_impl.buf = b;\n o->private_impl.mark = data.ptr;\n o->private_impl.limit = data.ptr + data.len;\n *ioptr1_ptr = data.ptr;\n *ioptr2_ptr = data.ptr + data.len;\n return ((wuffs_base__empty_struct){});\n}\n\nstatic inline wuffs_base__empty_struct //\nwuffs_base__io_writer__set_mark(wuffs_base__io_writer*" + + " o, uint8_t* mark) {\n o->private_impl.mark = mark;\n return ((wuffs_base__empty_struct){});\n}\n" + "" const baseIOPublicH = "" + diff --git a/cmd/wuffs-c/internal/cgen/var.go b/cmd/wuffs-c/internal/cgen/var.go index 3ff45b21..438c1099 100644 --- a/cmd/wuffs-c/internal/cgen/var.go +++ b/cmd/wuffs-c/internal/cgen/var.go @@ -89,6 +89,9 @@ func (g *gen) writeLoadDerivedVar(b *buffer, hack string, prefix string, name t. if hack == "w" { b.printf("%s%sw = %sw.data.ptr + %sw.meta.wi;\n", iopPrefix, vPrefix, uPrefix, uPrefix) return nil + } else if hack == "r" { + b.printf("%s%sr = %sr.data.ptr + %sr.meta.ri;\n", iopPrefix, vPrefix, uPrefix, uPrefix) + return nil } if !typ.IsIOType() { @@ -151,6 +154,9 @@ func (g *gen) writeSaveDerivedVar(b *buffer, hack string, prefix string, name t. if hack == "w" { b.printf("%sw.meta.wi = %s%sw - %sw.data.ptr;\n", uPrefix, iopPrefix, vPrefix, uPrefix) return nil + } else if hack == "r" { + b.printf("%sr.meta.ri = %s%sr - %sr.data.ptr;\n", uPrefix, iopPrefix, vPrefix, uPrefix) + return nil } if !typ.IsIOType() { @@ -188,11 +194,11 @@ func (g *gen) writeLoadExprDerivedVars(b *buffer, n *a.Expr) error { prefix := aPrefix // TODO: don't hard-code these. hack := "" - if s := o.Value().Str(g.tm); s != "args.dst" && s != "args.src" && s != "w" { + if s := o.Value().Str(g.tm); s != "args.dst" && s != "args.src" && s != "w" && s != "r" { continue - } else if s == "w" { + } else if s == "w" || s == "r" { prefix = vPrefix - hack = "w" + hack = s } if err := g.writeLoadDerivedVar(b, hack, prefix, o.Name(), o.Value().MType(), false); err != nil { return err @@ -213,11 +219,11 @@ func (g *gen) writeSaveExprDerivedVars(b *buffer, n *a.Expr) error { prefix := aPrefix // TODO: don't hard-code these. hack := "" - if s := o.Value().Str(g.tm); s != "args.dst" && s != "args.src" && s != "w" { + if s := o.Value().Str(g.tm); s != "args.dst" && s != "args.src" && s != "w" && s != "r" { continue - } else if s == "w" { + } else if s == "w" || s == "r" { prefix = vPrefix - hack = "w" + hack = s } if err := g.writeSaveDerivedVar(b, hack, prefix, o.Name(), o.Value().MType()); err != nil { return err diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index 85ff2f6f..2c217822 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -208,6 +208,7 @@ var Funcs = []string{ "io_reader.set_limit!(l u64)", // TODO: remove, as it's no longer used? "io_reader.set_mark!()", "io_reader.since_mark() slice u8", + "io_reader.take!(n u64) slice u8", "io_reader.skip!??(n u32)", diff --git a/lang/token/list.go b/lang/token/list.go index cfdcbe2c..ac0e6fd7 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -441,28 +441,29 @@ const ( IDBase = ID(0x131) IDThis = ID(0x132) - IDFrameConfig = ID(0x160) - IDImageConfig = ID(0x161) - IDPixelBuffer = ID(0x162) - IDPixelConfig = ID(0x163) - IDPixelSwizzler = ID(0x164) + IDFrameConfig = ID(0x150) + IDImageConfig = ID(0x151) + IDPixelBuffer = ID(0x152) + IDPixelConfig = ID(0x153) + IDPixelSwizzler = ID(0x154) - IDDecodeFrameOptions = ID(0x168) + IDDecodeFrameOptions = ID(0x158) - IDCanUndoByte = ID(0x170) - IDPosition = ID(0x171) - IDSetLimit = ID(0x172) - IDSetMark = ID(0x173) - IDSinceMark = ID(0x174) - IDSinceMarkLength = ID(0x175) - IDSkip = ID(0x176) - IDSkipFast = ID(0x177) + IDCanUndoByte = ID(0x160) + IDPosition = ID(0x161) + IDSetLimit = ID(0x162) + IDSetMark = ID(0x163) + IDSinceMark = ID(0x164) + IDSinceMarkLength = ID(0x165) + IDSkip = ID(0x166) + IDSkipFast = ID(0x167) + IDTake = ID(0x168) - IDCopyFromSlice = ID(0x178) - IDCopyNFromHistory = ID(0x179) - IDCopyNFromHistoryFast = ID(0x17A) - IDCopyNFromReader = ID(0x17B) - IDCopyNFromSlice = ID(0x17C) + IDCopyFromSlice = ID(0x170) + IDCopyNFromHistory = ID(0x171) + IDCopyNFromHistoryFast = ID(0x172) + IDCopyNFromReader = ID(0x173) + IDCopyNFromSlice = ID(0x174) // -------- 0x180 block. @@ -786,6 +787,7 @@ var builtInsByID = [nBuiltInIDs]string{ IDSinceMarkLength: "since_mark_length", IDSkip: "skip", IDSkipFast: "skip_fast", + IDTake: "take", IDCopyFromSlice: "copy_from_slice", IDCopyNFromHistory: "copy_n_from_history", diff --git a/release/c/wuffs-unsupported-snapshot.h b/release/c/wuffs-unsupported-snapshot.h index cb265f07..35327658 100644 --- a/release/c/wuffs-unsupported-snapshot.h +++ b/release/c/wuffs-unsupported-snapshot.h @@ -2757,8 +2757,11 @@ struct wuffs_gif__decoder__struct { uint32_t f_dst_x; uint32_t f_dst_y; wuffs_base__range_ie_u32 f_dirty_y; + uint64_t f_compressed_ri; + uint64_t f_compressed_wi; uint32_t f_uncompressed_ri; uint32_t f_uncompressed_wi; + uint8_t f_compressed[4096]; uint8_t f_uncompressed[4096]; uint8_t f_palettes[2][1024]; uint8_t f_dst_palette[1024]; @@ -2821,6 +2824,7 @@ struct wuffs_gif__decoder__struct { uint32_t v_num_palette_entries; uint32_t v_i; uint64_t v_block_size; + wuffs_base__status v_z; uint64_t scratch; } c_decode_id_part1[1]; } private_impl; @@ -3803,6 +3807,26 @@ wuffs_base__io_writer__copy_n_from_slice(uint8_t** ptr_ioptr_w, return n; } +static inline wuffs_base__empty_struct // +wuffs_base__io_reader__set(wuffs_base__io_reader* o, + wuffs_base__io_buffer* b, + uint8_t** ptr_iop, + uint8_t** ptr_io1, + wuffs_base__slice_u8 data) { + b->data = data; + b->meta.wi = data.len; + b->meta.ri = 0; + b->meta.pos = 0; + b->meta.closed = false; + + o->private_impl.buf = b; + o->private_impl.mark = data.ptr; + o->private_impl.limit = data.ptr + data.len; + *ptr_iop = data.ptr; + *ptr_io1 = data.ptr + data.len; + return ((wuffs_base__empty_struct){}); +} + static inline wuffs_base__empty_struct // wuffs_base__io_reader__set_limit(wuffs_base__io_reader* o, uint8_t* ioptr_r, @@ -3819,24 +3843,36 @@ wuffs_base__io_reader__set_mark(wuffs_base__io_reader* o, uint8_t* mark) { return ((wuffs_base__empty_struct){}); } +static inline wuffs_base__slice_u8 // +wuffs_base__io_reader__take(uint8_t** ptr_iop, uint8_t* io1, uint64_t n) { + if (n <= (io1 - *ptr_iop)) { + uint8_t* p = *ptr_iop; + *ptr_iop += n; + return ((wuffs_base__slice_u8){ + .ptr = p, + .len = n, + }); + } + return ((wuffs_base__slice_u8){}); +} + static inline wuffs_base__empty_struct // wuffs_base__io_writer__set(wuffs_base__io_writer* o, wuffs_base__io_buffer* b, uint8_t** ioptr1_ptr, uint8_t** ioptr2_ptr, - wuffs_base__slice_u8 s) { - b->data.ptr = s.ptr; - b->data.len = s.len; + wuffs_base__slice_u8 data) { + b->data = data; b->meta.wi = 0; b->meta.ri = 0; b->meta.pos = 0; b->meta.closed = false; o->private_impl.buf = b; - o->private_impl.mark = s.ptr; - o->private_impl.limit = s.ptr + s.len; - *ioptr1_ptr = s.ptr; - *ioptr2_ptr = s.ptr + s.len; + o->private_impl.mark = data.ptr; + o->private_impl.limit = data.ptr + data.len; + *ioptr1_ptr = data.ptr; + *ioptr2_ptr = data.ptr + data.len; return ((wuffs_base__empty_struct){}); } @@ -7149,9 +7185,10 @@ wuffs_lzw__decoder__decode(wuffs_lzw__decoder* self, goto suspend; } v_j = 0; + } else { + status = wuffs_base__suspension__short_read; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); } - status = wuffs_base__suspension__short_read; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(2); } v_bits |= (((uint32_t)(wuffs_base__load_u8be(iop_a_src))) << v_n_bits); @@ -9156,6 +9193,8 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_base__slice_u8 v_dst_palette; uint8_t v_lw; uint64_t v_block_size; + uint64_t v_n_compressed; + wuffs_base__slice_u8 v_compressed; wuffs_base__io_writer v_w; wuffs_base__io_buffer u_w; uint8_t* iop_v_w = NULL; @@ -9163,6 +9202,13 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(u_w); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iop_v_w); WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_v_w); + wuffs_base__io_reader v_r; + wuffs_base__io_buffer u_r; + uint8_t* iop_v_r = NULL; + uint8_t* io1_v_r = NULL; + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(u_r); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(iop_v_r); + WUFFS_BASE__IGNORE_POTENTIALLY_UNUSED_VARIABLE(io1_v_r); wuffs_base__status v_z; uint64_t v_wi; @@ -9194,12 +9240,17 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, v_dst_palette = ((wuffs_base__slice_u8){}); v_lw = 0; v_block_size = self->private_impl.c_decode_id_part1[0].v_block_size; + v_n_compressed = 0; + v_compressed = ((wuffs_base__slice_u8){}); v_w = ((wuffs_base__io_writer){}); - v_z = NULL; + v_r = ((wuffs_base__io_reader){}); + v_z = self->private_impl.c_decode_id_part1[0].v_z; v_wi = 0; } else { v_dst_palette = ((wuffs_base__slice_u8){}); + v_compressed = ((wuffs_base__slice_u8){}); v_w = ((wuffs_base__io_writer){}); + v_r = ((wuffs_base__io_reader){}); } switch (coro_susp_point) { WUFFS_BASE__COROUTINE_SUSPENSION_POINT_0; @@ -9338,29 +9389,59 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, wuffs_lzw__decoder__set_literal_width(&self->private_impl.f_lzw, ((uint32_t)(v_lw))); self->private_impl.f_previous_lzw_decode_ended_abruptly = true; - while (true) { - if (((uint64_t)(io1_a_src - iop_a_src)) == 0) { - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); - if (status) { - goto exit; + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { + status = wuffs_base__suspension__short_read; + goto suspend; + } + uint64_t t_3 = *iop_a_src++; + v_block_size = t_3; + } + label_0_continue:; + while (v_block_size > 0) { + while (((uint64_t)(io1_a_src - iop_a_src)) == 0) { + status = wuffs_base__suspension__short_read; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); + } + if (self->private_impl.f_compressed_ri == + self->private_impl.f_compressed_wi) { + self->private_impl.f_compressed_ri = 0; + self->private_impl.f_compressed_wi = 0; + } + while (self->private_impl.f_compressed_wi <= 3841) { + v_n_compressed = wuffs_base__u64__min( + v_block_size, ((uint64_t)(io1_a_src - iop_a_src))); + if (v_n_compressed <= 0) { + goto label_1_break; + } + v_compressed = + wuffs_base__io_reader__take(&iop_a_src, io1_a_src, v_n_compressed); + wuffs_base__slice_u8__copy_from_slice( + wuffs_base__slice_u8__subslice_i( + ((wuffs_base__slice_u8){ + .ptr = self->private_impl.f_compressed, + .len = 4096, + }), + self->private_impl.f_compressed_wi), + v_compressed); + wuffs_base__u64__sat_add_indirect(&self->private_impl.f_compressed_wi, + v_n_compressed); + wuffs_base__u64__sat_sub_indirect(&v_block_size, v_n_compressed); + if (v_block_size > 0) { + goto label_1_break; + } + { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(7); + if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { + status = wuffs_base__suspension__short_read; + goto suspend; } + uint64_t t_4 = *iop_a_src++; + v_block_size = t_4; } } - { - WUFFS_BASE__COROUTINE_SUSPENSION_POINT(5); - if (WUFFS_BASE__UNLIKELY(iop_a_src == io1_a_src)) { - status = wuffs_base__suspension__short_read; - goto suspend; - } - uint64_t t_3 = *iop_a_src++; - v_block_size = t_3; - } - if (v_block_size == 0) { - goto label_0_break; - } - self->private_impl.f_previous_lzw_decode_ended_abruptly = true; + label_1_break:; if (((uint64_t)(self->private_impl.f_width)) < ((uint64_t)(a_workbuf.len))) { a_workbuf = wuffs_base__slice_u8__subslice_j( @@ -9370,9 +9451,16 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, status = wuffs_base__error__bad_workbuf_length; goto exit; } - label_1_continue:; + label_2_continue:; while (true) { v_w = ((wuffs_base__io_writer){}); + v_r = ((wuffs_base__io_reader){}); + if ((self->private_impl.f_compressed_ri > + self->private_impl.f_compressed_wi) || + (self->private_impl.f_compressed_wi > 4096)) { + status = wuffs_gif__error__internal_error_inconsistent_ri_wi; + goto exit; + } { wuffs_base__io_writer o_0_v_w = v_w; uint8_t* o_0_iop_v_w = iop_v_w; @@ -9386,78 +9474,94 @@ wuffs_gif__decoder__decode_id_part1(wuffs_gif__decoder* self, }), self->private_impl.f_uncompressed_wi)); { - wuffs_base__io_reader o_1_a_src = a_src; - wuffs_base__io_reader__set_limit(&a_src, iop_a_src, v_block_size); - wuffs_base__io_reader__set_mark(&a_src, iop_a_src); + wuffs_base__io_reader o_1_v_r = v_r; + uint8_t* o_1_iop_v_r = iop_v_r; + uint8_t* o_1_io1_v_r = io1_v_r; + wuffs_base__io_reader__set( + &v_r, &u_r, &iop_v_r, &io1_v_r, + wuffs_base__slice_u8__subslice_ij( + ((wuffs_base__slice_u8){ + .ptr = self->private_impl.f_compressed, + .len = 4096, + }), + self->private_impl.f_compressed_ri, + self->private_impl.f_compressed_wi)); { u_w.meta.wi = iop_v_w - u_w.data.ptr; - if (a_src.private_impl.buf) { - a_src.private_impl.buf->meta.ri = - iop_a_src - a_src.private_impl.buf->data.ptr; - } - wuffs_base__status t_4 = wuffs_lzw__decoder__decode( - &self->private_impl.f_lzw, v_w, a_src); + u_r.meta.ri = iop_v_r - u_r.data.ptr; + wuffs_base__status t_5 = wuffs_lzw__decoder__decode( + &self->private_impl.f_lzw, v_w, v_r); iop_v_w = u_w.data.ptr + u_w.meta.wi; - if (a_src.private_impl.buf) { - iop_a_src = a_src.private_impl.buf->data.ptr + - a_src.private_impl.buf->meta.ri; - } - v_z = t_4; + iop_v_r = u_r.data.ptr + u_r.meta.ri; + v_z = t_5; } v_wi = wuffs_base__u64__sat_add( ((uint64_t)(self->private_impl.f_uncompressed_wi)), ((uint64_t)(iop_v_w - v_w.private_impl.mark))); self->private_impl.f_uncompressed_wi = ((uint32_t)(wuffs_base__u64__min(v_wi, 4096))); - wuffs_base__u64__sat_sub_indirect( - &v_block_size, - ((uint64_t)(iop_a_src - a_src.private_impl.mark))); - a_src = o_1_a_src; + wuffs_base__u64__sat_add_indirect( + &self->private_impl.f_compressed_ri, + ((uint64_t)(iop_v_r - v_r.private_impl.mark))); + v_r = o_1_v_r; + iop_v_r = o_1_iop_v_r; + io1_v_r = o_1_io1_v_r; } v_w = o_0_v_w; iop_v_w = o_0_iop_v_w; io1_v_w = o_0_io1_v_w; } - if ((v_block_size == 0) && - (v_z == wuffs_base__suspension__short_read)) { - goto label_1_break; - } - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); - if (status) { - goto exit; - } + status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); + if (status) { + goto exit; } if (wuffs_base__status__is_ok(v_z)) { self->private_impl.f_previous_lzw_decode_ended_abruptly = false; - goto label_1_break; - } - if (v_z == wuffs_base__suspension__short_write) { - goto label_1_continue; + if (v_block_size > 0) { + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(8); + self->private_impl.c_decode_id_part1[0].scratch = + ((uint32_t)(v_block_size)); + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(9); + if (self->private_impl.c_decode_id_part1[0].scratch > + ((uint64_t)(io1_a_src - iop_a_src))) { + self->private_impl.c_decode_id_part1[0].scratch -= + io1_a_src - iop_a_src; + iop_a_src = io1_a_src; + status = wuffs_base__suspension__short_read; + goto suspend; + } + iop_a_src += self->private_impl.c_decode_id_part1[0].scratch; + WUFFS_BASE__COROUTINE_SUSPENSION_POINT(10); + if (a_src.private_impl.buf) { + a_src.private_impl.buf->meta.ri = + iop_a_src - a_src.private_impl.buf->data.ptr; + } + status = wuffs_gif__decoder__skip_blocks(self, a_src); + if (a_src.private_impl.buf) { + iop_a_src = a_src.private_impl.buf->data.ptr + + a_src.private_impl.buf->meta.ri; + } + if (status) { + goto suspend; + } + } + goto label_0_break; + } else if (v_z == wuffs_base__suspension__short_read) { + goto label_0_continue; + } else if (v_z == wuffs_base__suspension__short_write) { + goto label_2_continue; } status = v_z; - WUFFS_BASE__COROUTINE_SUSPENSION_POINT_MAYBE_SUSPEND(6); - if (((uint64_t)(self->private_impl.f_width)) < - ((uint64_t)(a_workbuf.len))) { - a_workbuf = wuffs_base__slice_u8__subslice_j( - a_workbuf, ((uint64_t)(self->private_impl.f_width))); - } else if (((uint64_t)(self->private_impl.f_width)) > - ((uint64_t)(a_workbuf.len))) { - status = wuffs_base__error__bad_workbuf_length; + if (wuffs_base__status__is_error(status)) { + goto exit; + } else if (wuffs_base__status__is_suspension(status)) { + status = wuffs_base__error__cannot_return_a_suspension; goto exit; } + goto ok; } - label_1_break:; } label_0_break:; - if (self->private_impl.f_uncompressed_ri != - self->private_impl.f_uncompressed_wi) { - status = wuffs_gif__decoder__copy_to_image_buffer(self, a_dst); - if (status) { - goto exit; - } - } goto ok; ok: @@ -9472,6 +9576,7 @@ suspend: v_num_palette_entries; self->private_impl.c_decode_id_part1[0].v_i = v_i; self->private_impl.c_decode_id_part1[0].v_block_size = v_block_size; + self->private_impl.c_decode_id_part1[0].v_z = v_z; goto exit; exit: diff --git a/std/gif/decode_gif.wuffs b/std/gif/decode_gif.wuffs index bf6a593d..7d0ddd83 100644 --- a/std/gif/decode_gif.wuffs +++ b/std/gif/decode_gif.wuffs @@ -107,8 +107,12 @@ pub struct decoder?( dst_y base.u32, dirty_y base.range_ie_u32, + compressed_ri base.u64, + compressed_wi base.u64, uncompressed_ri base.u32[..4096], uncompressed_wi base.u32[..4096], + + compressed array[4096] base.u8, uncompressed array[4096] base.u8, // palettes[0] and palettes[1] are the Global and Local Color Table. @@ -619,17 +623,31 @@ pri func decoder.decode_id_part1!??(dst ptr base.pixel_buffer, src base.io_reade this.lzw.set_literal_width!(lw:lw as base.u32) this.previous_lzw_decode_ended_abruptly = true - while true { - if args.src.available() == 0 { - if this.uncompressed_ri != this.uncompressed_wi { - this.copy_to_image_buffer!?(pb:args.dst) + + var block_size base.u64[..255] = args.src.read_u8_as_u64!??() + while:outer block_size > 0 { + while args.src.available() == 0 { + yield base."$short read" + } + + if this.compressed_ri == this.compressed_wi { + this.compressed_ri = 0 + this.compressed_wi = 0 + } + while this.compressed_wi <= (4096 - 255) { + var n_compressed base.u64 = block_size.min(x:args.src.available()) + if n_compressed <= 0 { + break } + var compressed slice base.u8 = args.src.take!(n:n_compressed) + this.compressed[this.compressed_wi:].copy_from_slice!(s:compressed) + this.compressed_wi ~sat+= n_compressed + block_size ~sat-= n_compressed + if block_size > 0 { + break + } + block_size = args.src.read_u8_as_u64!??() } - var block_size base.u64[..255] = args.src.read_u8_as_u64!??() - if block_size == 0 { - break - } - this.previous_lzw_decode_ended_abruptly = true if (this.width as base.u64) < args.workbuf.length() { args.workbuf = args.workbuf[:this.width as base.u64] @@ -639,47 +657,40 @@ pri func decoder.decode_id_part1!??(dst ptr base.pixel_buffer, src base.io_reade while:inner true { var w base.io_writer + var r base.io_reader + if (this.compressed_ri > this.compressed_wi) or (this.compressed_wi > 4096) { + return "?internal error: inconsistent ri/wi" + } io_bind (io:w, data:this.uncompressed[this.uncompressed_wi:]) { - io_limit (io:args.src, limit:block_size) { - args.src.set_mark!() - var z base.status =? this.lzw.decode!??(dst:w, src:args.src) + io_bind (io:r, data:this.compressed[this.compressed_ri:this.compressed_wi]) { + var z base.status =? this.lzw.decode!??(dst:w, src:r) var wi base.u64 = (this.uncompressed_wi as base.u64) ~sat+ w.since_mark().length() this.uncompressed_wi = wi.min(x:4096) as base.u32 - block_size ~sat-= args.src.since_mark().length() + this.compressed_ri ~sat+= r.since_mark().length() } } - if (block_size == 0) and (z == base."$short read") { - break:inner - } - - if this.uncompressed_ri != this.uncompressed_wi { - this.copy_to_image_buffer!?(pb:args.dst) - } + this.copy_to_image_buffer!?(pb:args.dst) if z.is_ok() { - // TODO: check that block_size is zero? this.previous_lzw_decode_ended_abruptly = false - break:inner - } - if z == base."$short write" { + + // Skip any trailing blocks. + if block_size > 0 { + args.src.skip!??(n:block_size as base.u32) + this.skip_blocks!??(src:args.src) + } + + break:outer + } else if z == base."$short read" { + continue:outer + } else if z == base."$short write" { continue:inner } - - yield z - - if (this.width as base.u64) < args.workbuf.length() { - args.workbuf = args.workbuf[:this.width as base.u64] - } else if (this.width as base.u64) > args.workbuf.length() { - return base."?bad workbuf length" - } + return z } } - if this.uncompressed_ri != this.uncompressed_wi { - this.copy_to_image_buffer!?(pb:args.dst) - } - // TODO: check for "not enough pixel data". } diff --git a/std/lzw/decode_lzw.wuffs b/std/lzw/decode_lzw.wuffs index 17ded18f..92e7756c 100644 --- a/std/lzw/decode_lzw.wuffs +++ b/std/lzw/decode_lzw.wuffs @@ -89,8 +89,9 @@ pub func decoder.decode!??(dst base.io_writer, src base.io_reader) { this.flush_j = j this.flush!??(dst:args.dst) j = 0 + } else { + yield base."$short read" } - yield base."$short read" } bits |= (args.src.peek_u8() as base.u32) << n_bits args.src.skip_fast!(actual:1, worst_case:1)