Collect GIF's LZW data into larger batches

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)
This commit is contained in:
Nigel Tao committed 2018-12-15 14:10:10 +11:00
1 parent e497b38da0
commit 33a4557d98
9 files changed
+325 -158

No files matched your search

+39 -7
View File
@@ -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){});
}
+15 -7
View File
@@ -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 {
+4 -3
View File
@@ -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 = "" +
+12 -6
View File
@@ -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
+1
View File
@@ -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)",
+21 -19
View File
@@ -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",
+184 -79
View File
@@ -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:
+47 -36
View File
@@ -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".
}
+2 -1
View File
@@ -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)