mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
std/jpeg: call slice.bulk_memset
This commit is contained in:
1 parent
5edfe45e15
commit
2f18dc61d0
8 files changed
+160
-91
No files matched your search
@@ -214,6 +214,14 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
|
||||
return len;
|
||||
}
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__bulk_memset(void* ptr, size_t len, uint8_t byte_value) {
|
||||
if (len) {
|
||||
memset(ptr, byte_value, len);
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
|
||||
@@ -872,6 +872,69 @@ func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []*
|
||||
|
||||
func (g *gen) writeBuiltinSlice(b *buffer, recv *a.Expr, method t.ID, args []*a.Node, sideEffectsOnly bool, depth uint32) error {
|
||||
switch method {
|
||||
case t.IDBulkMemset:
|
||||
if arrayOrSlice, lo, hi, ok := recv.IsSlice(); !ok {
|
||||
return fmt.Errorf("TODO: bulk_memset for general expressions")
|
||||
|
||||
} else if hi == nil {
|
||||
return fmt.Errorf("TODO: bulk_memset for general expressions")
|
||||
|
||||
} else if arrayOrSlice.MType().IsBulkNumType() {
|
||||
b.writes("wuffs_base__bulk_memset(&")
|
||||
if err := g.writeExpr(b, arrayOrSlice, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
if lo == nil {
|
||||
b.writes("[0], ")
|
||||
if err := g.writeExpr(b, hi, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
b.writes("[")
|
||||
if err := g.writeExpr(b, lo, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes("], (")
|
||||
if err := g.writeExpr(b, hi, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(" - ")
|
||||
if err := g.writeExpr(b, lo, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(")")
|
||||
}
|
||||
if bs := arrayOrSlice.MType().Inner().BulkSize(); (bs != nil) && (bs.Cmp(one) != 0) {
|
||||
b.writes(" * (size_t)")
|
||||
b.writes(bs.String())
|
||||
b.writes("u")
|
||||
}
|
||||
b.writes(", ")
|
||||
|
||||
return g.writeArgs(b, args, depth)
|
||||
|
||||
} else if arrayOrSlice.MType().IsContainerOfSpecificNumType(t.IDSlice, t.IDU8) {
|
||||
b.writes("wuffs_base__bulk_memset(")
|
||||
if err := g.writeExpr(b, recv, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(".ptr, ")
|
||||
if err := g.writeExpr(b, recv, false, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(".len")
|
||||
if bs := arrayOrSlice.MType().Inner().BulkSize(); (bs != nil) && (bs.Cmp(one) != 0) {
|
||||
b.writes(" * (size_t)")
|
||||
b.writes(bs.String())
|
||||
b.writes("u")
|
||||
}
|
||||
b.writes(", ")
|
||||
return g.writeArgs(b, args, depth)
|
||||
|
||||
} else {
|
||||
return fmt.Errorf("TODO: bulk_memset for general expressions")
|
||||
}
|
||||
|
||||
case t.IDCopyFromSlice:
|
||||
if err := g.writeBuiltinSliceCopyFromSlice8(b, recv, method, args, depth); err != errOptimizationNotApplicable {
|
||||
return err
|
||||
|
||||
@@ -838,6 +838,33 @@ func (n *TypeExpr) Pointee() *TypeExpr {
|
||||
return n
|
||||
}
|
||||
|
||||
func (n *TypeExpr) BulkSize() *big.Int {
|
||||
if !n.IsBulkNumType() {
|
||||
return nil
|
||||
}
|
||||
ret := big.NewInt(1)
|
||||
for ; n.id0 == t.IDArray; n = n.rhs.AsTypeExpr() {
|
||||
ret = ret.Mul(ret, n.ArrayLength().ConstValue())
|
||||
}
|
||||
switch n.id2 {
|
||||
case t.IDU8:
|
||||
return ret
|
||||
case t.IDU16:
|
||||
return ret.Lsh(ret, 1)
|
||||
case t.IDU32:
|
||||
return ret.Lsh(ret, 2)
|
||||
case t.IDU64:
|
||||
return ret.Lsh(ret, 3)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (n *TypeExpr) IsBulkNumType() bool {
|
||||
for ; n.id0 == t.IDArray; n = n.rhs.AsTypeExpr() {
|
||||
}
|
||||
return n.id0 == 0 && n.id1 == t.IDBase && n.id2.IsNumType()
|
||||
}
|
||||
|
||||
func (n *TypeExpr) IsBool() bool {
|
||||
return n.id0 == 0 && n.id1 == t.IDBase && n.id2 == t.IDBool
|
||||
}
|
||||
@@ -914,6 +941,10 @@ func (n *TypeExpr) IsReadOnly() bool {
|
||||
return (n.id0 == t.IDRoarray) || (n.id0 == t.IDRoslice) || (n.id0 == t.IDRotable)
|
||||
}
|
||||
|
||||
func (n *TypeExpr) IsContainerOfSpecificNumType(container t.ID, numType t.ID) bool {
|
||||
return (n.id0 == container) && n.Inner().IsNumType() && (n.Inner().id2 == numType)
|
||||
}
|
||||
|
||||
func (n *TypeExpr) IsUnsignedInteger() bool {
|
||||
return n.id0 == 0 && n.id1 == t.IDBase &&
|
||||
(n.id2 == t.IDU8 || n.id2 == t.IDU16 || n.id2 == t.IDU32 || n.id2 == t.IDU64)
|
||||
|
||||
@@ -964,6 +964,11 @@ var SliceFuncs = []string{
|
||||
"GENERIC T1.prefix(up_to: u64) T1",
|
||||
"GENERIC T1.uintptr_low_12_bits() u32[..= 4095]",
|
||||
"GENERIC T1.suffix(up_to: u64) T1",
|
||||
|
||||
// The bulk_etc methods are further restricted to those slices whose
|
||||
// elements are bulk-numeric types: numerics (e.g. base.u32), arrays of
|
||||
// numerics, arrays of arrays of numerics, etc.
|
||||
"GENERIC T1.bulk_memset!(byte_value: u8)",
|
||||
}
|
||||
|
||||
var SliceU8Funcs = []string{
|
||||
|
||||
+10
-2
@@ -730,8 +730,16 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
qqid[0] = t.IDBase
|
||||
qqid[1] = t.IDDagger1
|
||||
if q.c.isBuiltInSliceFunc(qqid, lTyp) {
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil))
|
||||
return nil
|
||||
bulky := false
|
||||
switch qqid[2] {
|
||||
case t.IDBulkMemset:
|
||||
bulky = true
|
||||
}
|
||||
|
||||
if !bulky || lTyp.Inner().IsBulkNumType() {
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil))
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("check: no %s method %q", lTyp.Decorator().Str(q.tm), n.Ident().Str(q.tm))
|
||||
|
||||
|
||||
+9
-9
@@ -668,14 +668,14 @@ const (
|
||||
IDIsOK = ID(0x231)
|
||||
IDIsSuspension = ID(0x232)
|
||||
|
||||
IDData = ID(0x240)
|
||||
IDHeight = ID(0x241)
|
||||
IDIO = ID(0x242)
|
||||
IDLimit = ID(0x243)
|
||||
IDPrefix = ID(0x244)
|
||||
IDRowU32 = ID(0x245)
|
||||
IDStride = ID(0x246)
|
||||
IDSubslice = ID(0x247)
|
||||
IDBulkMemset = ID(0x240)
|
||||
IDData = ID(0x241)
|
||||
IDHeight = ID(0x242)
|
||||
IDIO = ID(0x243)
|
||||
IDLimit = ID(0x244)
|
||||
IDPrefix = ID(0x245)
|
||||
IDRowU32 = ID(0x246)
|
||||
IDStride = ID(0x247)
|
||||
IDSubtable = ID(0x248)
|
||||
IDSuffix = ID(0x249)
|
||||
IDUintptrLow12Bits = ID(0x24A)
|
||||
@@ -1100,6 +1100,7 @@ var builtInsByID = [nBuiltInIDs]string{
|
||||
IDIsOK: "is_ok",
|
||||
IDIsSuspension: "is_suspension",
|
||||
|
||||
IDBulkMemset: "bulk_memset",
|
||||
IDData: "data",
|
||||
IDHeight: "height",
|
||||
IDIO: "io",
|
||||
@@ -1107,7 +1108,6 @@ var builtInsByID = [nBuiltInIDs]string{
|
||||
IDPrefix: "prefix",
|
||||
IDRowU32: "row_u32",
|
||||
IDStride: "stride",
|
||||
IDSubslice: "subslice",
|
||||
IDSubtable: "subtable",
|
||||
IDSuffix: "suffix",
|
||||
IDUintptrLow12Bits: "uintptr_low_12_bits",
|
||||
|
||||
@@ -12277,6 +12277,14 @@ wuffs_base__slice_u8__copy_from_slice(wuffs_base__slice_u8 dst,
|
||||
return len;
|
||||
}
|
||||
|
||||
static inline wuffs_base__empty_struct //
|
||||
wuffs_base__bulk_memset(void* ptr, size_t len, uint8_t byte_value) {
|
||||
if (len) {
|
||||
memset(ptr, byte_value, len);
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// --------
|
||||
|
||||
static inline wuffs_base__slice_u8 //
|
||||
@@ -36853,10 +36861,6 @@ wuffs_jpeg__decoder__fill_bitstream(
|
||||
wuffs_jpeg__decoder* self,
|
||||
wuffs_base__io_buffer* a_src);
|
||||
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_jpeg__decoder__clear_mcu_blocks(
|
||||
wuffs_jpeg__decoder* self);
|
||||
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_jpeg__decoder__load_mcu_blocks(
|
||||
wuffs_jpeg__decoder* self,
|
||||
@@ -38937,8 +38941,6 @@ wuffs_jpeg__decoder__do_decode_frame(
|
||||
|
||||
uint32_t v_pixfmt = 0;
|
||||
wuffs_base__status v_status = wuffs_base__make_status(NULL);
|
||||
uint64_t v_i = 0;
|
||||
uint64_t v_i_end = 0;
|
||||
uint8_t v_c = 0;
|
||||
uint8_t v_marker = 0;
|
||||
|
||||
@@ -38997,15 +38999,15 @@ wuffs_jpeg__decoder__do_decode_frame(
|
||||
}
|
||||
goto ok;
|
||||
}
|
||||
v_i = self->private_impl.f_components_workbuf_offsets[4];
|
||||
v_i_end = self->private_impl.f_components_workbuf_offsets[8];
|
||||
if (v_i_end > ((uint64_t)(a_workbuf.len))) {
|
||||
if (self->private_impl.f_components_workbuf_offsets[8] > ((uint64_t)(a_workbuf.len))) {
|
||||
status = wuffs_base__make_status(wuffs_base__error__bad_workbuf_length);
|
||||
goto exit;
|
||||
}
|
||||
while (v_i < v_i_end) {
|
||||
a_workbuf.ptr[v_i] = 0;
|
||||
v_i += 1;
|
||||
} else if (self->private_impl.f_components_workbuf_offsets[4] < self->private_impl.f_components_workbuf_offsets[8]) {
|
||||
wuffs_base__bulk_memset(wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
self->private_impl.f_components_workbuf_offsets[4],
|
||||
self->private_impl.f_components_workbuf_offsets[8]).ptr, wuffs_base__slice_u8__subslice_ij(a_workbuf,
|
||||
self->private_impl.f_components_workbuf_offsets[4],
|
||||
self->private_impl.f_components_workbuf_offsets[8]).len, 0);
|
||||
}
|
||||
label__0__continue:;
|
||||
while (true) {
|
||||
@@ -39516,7 +39518,7 @@ wuffs_jpeg__decoder__decode_sos(
|
||||
if (self->private_impl.f_sof_marker >= 194) {
|
||||
wuffs_jpeg__decoder__load_mcu_blocks(self, v_mx, v_my, a_workbuf);
|
||||
} else {
|
||||
wuffs_jpeg__decoder__clear_mcu_blocks(self);
|
||||
wuffs_base__bulk_memset(&self->private_data.f_mcu_blocks[0], self->private_impl.f_mcu_num_blocks * (size_t)128u, 0);
|
||||
}
|
||||
while (true) {
|
||||
v_decode_mcu_result = wuffs_jpeg__decoder__decode_mcu(self);
|
||||
@@ -39916,7 +39918,7 @@ wuffs_jpeg__decoder__fill_bitstream(
|
||||
wuffs_base__io_buffer* a_src) {
|
||||
uint32_t v_wi = 0;
|
||||
uint8_t v_c = 0;
|
||||
uint32_t v_n = 0;
|
||||
uint32_t v_new_wi = 0;
|
||||
|
||||
const uint8_t* iop_a_src = NULL;
|
||||
const uint8_t* io0_a_src WUFFS_BASE__POTENTIALLY_UNUSED = NULL;
|
||||
@@ -39961,11 +39963,11 @@ wuffs_jpeg__decoder__fill_bitstream(
|
||||
label__0__break:;
|
||||
if (((uint64_t)(io2_a_src - iop_a_src)) > 1) {
|
||||
if ((wuffs_base__peek_u8be__no_bounds_check(iop_a_src) >= 255) && ((wuffs_base__peek_u16le__no_bounds_check(iop_a_src) >> 8) > 0)) {
|
||||
v_n = (wuffs_base__u32__min(v_wi, 2016) + 32);
|
||||
while (v_wi < v_n) {
|
||||
self->private_data.f_bitstream_buffer[v_wi] = 0;
|
||||
v_wi += 1;
|
||||
v_new_wi = (wuffs_base__u32__min(v_wi, 2016) + 32);
|
||||
if (v_wi < v_new_wi) {
|
||||
wuffs_base__bulk_memset(&self->private_data.f_bitstream_buffer[v_wi], (v_new_wi - v_wi), 0);
|
||||
}
|
||||
v_wi = v_new_wi;
|
||||
}
|
||||
}
|
||||
self->private_impl.f_bitstream_wi = v_wi;
|
||||
@@ -39976,26 +39978,6 @@ wuffs_jpeg__decoder__fill_bitstream(
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func jpeg.decoder.clear_mcu_blocks
|
||||
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_jpeg__decoder__clear_mcu_blocks(
|
||||
wuffs_jpeg__decoder* self) {
|
||||
uint32_t v_b = 0;
|
||||
uint32_t v_i = 0;
|
||||
|
||||
v_b = 0;
|
||||
while (v_b < self->private_impl.f_mcu_num_blocks) {
|
||||
v_i = 0;
|
||||
while (v_i < 64) {
|
||||
self->private_data.f_mcu_blocks[v_b][v_i] = 0;
|
||||
v_i += 1;
|
||||
}
|
||||
v_b += 1;
|
||||
}
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func jpeg.decoder.load_mcu_blocks
|
||||
|
||||
static wuffs_base__empty_struct
|
||||
|
||||
+13
-41
@@ -789,8 +789,6 @@ pub func decoder.decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reader,
|
||||
pri func decoder.do_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 pixfmt : base.u32
|
||||
var status : base.status
|
||||
var i : base.u64
|
||||
var i_end : base.u64
|
||||
var c : base.u8
|
||||
var marker : base.u8
|
||||
|
||||
@@ -819,19 +817,11 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
// For progressive JPEGs, zero-initialize the saved pre-IDCT blocks. For
|
||||
// sequential JPEGs, this is a no-op, other than checking that args.workbuf
|
||||
// is long enough.
|
||||
i = this.components_workbuf_offsets[4]
|
||||
i_end = this.components_workbuf_offsets[8]
|
||||
if i_end > args.workbuf.length() {
|
||||
if this.components_workbuf_offsets[8] > args.workbuf.length() {
|
||||
return base."#bad workbuf length"
|
||||
} else if this.components_workbuf_offsets[4] < this.components_workbuf_offsets[8] {
|
||||
args.workbuf[this.components_workbuf_offsets[4] .. this.components_workbuf_offsets[8]].bulk_memset!(byte_value: 0)
|
||||
}
|
||||
while i < i_end,
|
||||
inv i_end <= args.workbuf.length(),
|
||||
{
|
||||
assert i < 0xFFFF_FFFF_FFFF_FFFF via "a < b: a < c; c <= b"(c: i_end)
|
||||
assert i < args.workbuf.length() via "a < b: a < c; c <= b"(c: i_end)
|
||||
args.workbuf[i] = 0
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
// Process chunks (markers and their payloads).
|
||||
while true {
|
||||
@@ -1182,7 +1172,8 @@ pri func decoder.decode_sos?(dst: ptr base.pixel_buffer, src: base.io_reader, wo
|
||||
if this.sof_marker >= 0xC2 {
|
||||
this.load_mcu_blocks!(mx: mx, my: my, workbuf: args.workbuf)
|
||||
} else {
|
||||
this.clear_mcu_blocks!()
|
||||
// Clear this.mcu_blocks.
|
||||
this.mcu_blocks[.. this.mcu_num_blocks].bulk_memset!(byte_value: 0)
|
||||
}
|
||||
|
||||
while.decode_mcu true,
|
||||
@@ -1489,9 +1480,9 @@ pri func decoder.calculate_single_component_scan_fields!() {
|
||||
}
|
||||
|
||||
pri func decoder.fill_bitstream!(src: base.io_reader) {
|
||||
var wi : base.u32[..= 0x800]
|
||||
var c : base.u8
|
||||
var n : base.u32[..= 0x800]
|
||||
var wi : base.u32[..= 0x800]
|
||||
var c : base.u8
|
||||
var new_wi : base.u32[..= 0x800]
|
||||
|
||||
// Compact unread bytes to the start of the buffer.
|
||||
if this.bitstream_ri <= 0 {
|
||||
@@ -1533,36 +1524,17 @@ pri func decoder.fill_bitstream!(src: base.io_reader) {
|
||||
// this method can insert even more.
|
||||
if args.src.length() > 1 {
|
||||
if (args.src.peek_u8() >= 0xFF) and ((args.src.peek_u16le() >> 8) > 0) {
|
||||
n = wi.min(no_more_than: 0x800 - 32) + 32
|
||||
while wi < n {
|
||||
assert wi < 0x800 via "a < b: a < c; c <= b"(c: n)
|
||||
this.bitstream_buffer[wi] = 0x00
|
||||
wi += 1
|
||||
} endwhile
|
||||
new_wi = wi.min(no_more_than: 0x800 - 32) + 32
|
||||
if wi < new_wi {
|
||||
this.bitstream_buffer[wi .. new_wi].bulk_memset!(byte_value: 0)
|
||||
}
|
||||
wi = new_wi
|
||||
}
|
||||
}
|
||||
|
||||
this.bitstream_wi = wi
|
||||
}
|
||||
|
||||
pri func decoder.clear_mcu_blocks!() {
|
||||
var b : base.u32
|
||||
var i : base.u32
|
||||
|
||||
b = 0
|
||||
while b < this.mcu_num_blocks {
|
||||
assert b < 10 via "a < b: a < c; c <= b"(c: this.mcu_num_blocks)
|
||||
i = 0
|
||||
while i < 64,
|
||||
inv b < 10,
|
||||
{
|
||||
this.mcu_blocks[b][i] = 0
|
||||
i += 1
|
||||
} endwhile
|
||||
b += 1
|
||||
} endwhile
|
||||
}
|
||||
|
||||
pri func decoder.load_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2000], workbuf: slice base.u8) {
|
||||
var b : base.u32
|
||||
var csel : base.u8[..= 3]
|
||||
|
||||
Reference in new issue
Block a user