mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 00:38:14 +01:00
std: rename "var c" to "var c8"
This commit is contained in:
1 parent
77fa011072
commit
c77989d162
12 files changed
+741
-741
No files matched your search
@@ -144,30 +144,30 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
|
||||
}
|
||||
|
||||
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var i : base.u32
|
||||
var tag : base.u64
|
||||
var status : base.status
|
||||
var final_checksum_want : base.u32
|
||||
|
||||
// Read the header.
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x42 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x42 {
|
||||
return "#bad header"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x5A {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x5A {
|
||||
return "#bad header"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x68 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x68 {
|
||||
return "#bad header"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if (c < '1') or ('9' < c) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 < '1') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
this.max_incl_block_size = ((c - '0') as base.u32) * 100000
|
||||
this.max_incl_block_size = ((c8 - '0') as base.u32) * 100000
|
||||
|
||||
while true {
|
||||
// Read the 48-bit tag.
|
||||
@@ -175,8 +175,8 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
|
||||
i = 0
|
||||
while i < 48 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -244,8 +244,8 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
|
||||
i = 0
|
||||
while i < 32 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -261,7 +261,7 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
|
||||
}
|
||||
|
||||
pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var i : base.u32
|
||||
var j : base.u32
|
||||
var selector : base.u32
|
||||
@@ -274,8 +274,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < 32 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -288,8 +288,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
|
||||
// Read the "block randomized" bit.
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -304,8 +304,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < 24 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -327,8 +327,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < 256 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -350,8 +350,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
}
|
||||
while true {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -375,8 +375,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < 3 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -396,8 +396,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < 15 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -431,8 +431,8 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
inv i < 18001,
|
||||
{
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -497,7 +497,7 @@ pri func decoder.prepare_block?(src: base.io_reader) {
|
||||
}
|
||||
|
||||
pri func decoder.read_code_lengths?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var i : base.u32
|
||||
var code_length : base.u32
|
||||
|
||||
@@ -507,8 +507,8 @@ pri func decoder.read_code_lengths?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < 5 {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -531,8 +531,8 @@ pri func decoder.read_code_lengths?(src: base.io_reader) {
|
||||
}
|
||||
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
@@ -545,8 +545,8 @@ pri func decoder.read_code_lengths?(src: base.io_reader) {
|
||||
this.n_bits -= 1
|
||||
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
pri func decoder.decode_huffman_slow?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var node_index : base.u32[..= 256]
|
||||
|
||||
var child : base.u16
|
||||
@@ -36,8 +36,8 @@ pri func decoder.decode_huffman_slow?(src: base.io_reader) {
|
||||
node_index = 0
|
||||
while true {
|
||||
if this.n_bits <= 0 {
|
||||
c = args.src.read_u8?()
|
||||
this.bits = (c as base.u32) << 24
|
||||
c8 = args.src.read_u8?()
|
||||
this.bits = (c8 as base.u32) << 24
|
||||
this.n_bits = 8
|
||||
assert this.n_bits > 0
|
||||
}
|
||||
|
||||
@@ -133,7 +133,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
var vminor : base.u32[..= 0x1FF_FFFF]
|
||||
var vminor_alt : base.u32[..= 0x1FF_FFFF]
|
||||
var continued : base.u32[..= 1]
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var c_major : base.u8[..= 0x07]
|
||||
var c_minor : base.u8[..= 0x1F]
|
||||
var tagged : base.bool
|
||||
@@ -160,10 +160,10 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
yield? base."$short read"
|
||||
continue.outer
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
|
||||
if (indefinite_string_major_type <> 0) and (indefinite_string_major_type <> (c >> 5)) {
|
||||
if c <> 0xFF {
|
||||
if (indefinite_string_major_type <> 0) and (indefinite_string_major_type <> (c8 >> 5)) {
|
||||
if c8 <> 0xFF {
|
||||
return "#bad input"
|
||||
}
|
||||
vminor = (base.TOKEN__VBC__STRING << 21) |
|
||||
@@ -184,8 +184,8 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
}
|
||||
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
c_major = (c >> 5) as base.u8
|
||||
c_minor = c & 0x1F
|
||||
c_major = (c8 >> 5) as base.u8
|
||||
c_minor = c8 & 0x1F
|
||||
if c_minor < 0x18 {
|
||||
string_length = c_minor as base.u64
|
||||
} else {
|
||||
|
||||
+13
-13
@@ -672,7 +672,7 @@ pri func decoder.skip_blocks?(src: base.io_reader) {
|
||||
|
||||
// decode_ae reads an Application Extension.
|
||||
pri func decoder.decode_ae?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var block_size : base.u8
|
||||
var is_animexts : base.bool
|
||||
var is_netscape : base.bool
|
||||
@@ -705,11 +705,11 @@ pri func decoder.decode_ae?(src: base.io_reader) {
|
||||
is_xmp = true
|
||||
block_size = 0 // Re-purpose the block_size variable as a counter.
|
||||
while block_size < 11 {
|
||||
c = args.src.read_u8?()
|
||||
is_animexts = is_animexts and (c == ANIMEXTS1DOT0[block_size])
|
||||
is_netscape = is_netscape and (c == NETSCAPE2DOT0[block_size])
|
||||
is_iccp = is_iccp and (c == ICCRGBG1012[block_size])
|
||||
is_xmp = is_xmp and (c == XMPDATAXMP[block_size])
|
||||
c8 = args.src.read_u8?()
|
||||
is_animexts = is_animexts and (c8 == ANIMEXTS1DOT0[block_size])
|
||||
is_netscape = is_netscape and (c8 == NETSCAPE2DOT0[block_size])
|
||||
is_iccp = is_iccp and (c8 == ICCRGBG1012[block_size])
|
||||
is_xmp = is_xmp and (c8 == XMPDATAXMP[block_size])
|
||||
block_size += 1
|
||||
} endwhile
|
||||
|
||||
@@ -721,8 +721,8 @@ pri func decoder.decode_ae?(src: base.io_reader) {
|
||||
args.src.skip_u32?(n: block_size as base.u32)
|
||||
break.goto_done
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x01 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x01 {
|
||||
args.src.skip_u32?(n: 2)
|
||||
break.goto_done
|
||||
}
|
||||
@@ -767,12 +767,12 @@ pri func decoder.decode_ae?(src: base.io_reader) {
|
||||
|
||||
// decode_gc reads a Graphic Control.
|
||||
pri func decoder.decode_gc?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var flags : base.u8
|
||||
var gc_duration_centiseconds : base.u16
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if c <> 4 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 4 {
|
||||
return "#bad graphic control"
|
||||
}
|
||||
|
||||
@@ -799,8 +799,8 @@ pri func decoder.decode_gc?(src: base.io_reader) {
|
||||
this.gc_duration = (gc_duration_centiseconds as base.u64) * 7_056000
|
||||
this.gc_transparent_index = args.src.read_u8?()
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0 {
|
||||
return "#bad graphic control"
|
||||
}
|
||||
}
|
||||
|
||||
+11
-11
@@ -69,7 +69,7 @@ pub func decoder.transform_io?(dst: base.io_writer, src: base.io_reader, workbuf
|
||||
}
|
||||
|
||||
pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, workbuf: slice base.u8) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var flags : base.u8
|
||||
var xlen : base.u16
|
||||
var mark : base.u64
|
||||
@@ -80,16 +80,16 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
|
||||
var decoded_length_want : base.u32
|
||||
|
||||
// Read the header.
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x1F {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x1F {
|
||||
return "#bad header"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x8B {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x8B {
|
||||
return "#bad header"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x08 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x08 {
|
||||
return "#bad compression method"
|
||||
}
|
||||
flags = args.src.read_u8?()
|
||||
@@ -109,8 +109,8 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
|
||||
// filename length to NAME_MAX, which is 255.
|
||||
if (flags & 0x08) <> 0 {
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0 {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
@@ -119,8 +119,8 @@ pri func decoder.do_transform_io?(dst: base.io_writer, src: base.io_reader, work
|
||||
// Handle FCOMMENT.
|
||||
if (flags & 0x10) <> 0 {
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0 {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
|
||||
+77
-77
@@ -346,7 +346,7 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var marker : base.u8
|
||||
var pixfmt : base.u32
|
||||
|
||||
@@ -354,12 +354,12 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
return base."#bad call sequence"
|
||||
}
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0xFF {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0xFF {
|
||||
return "#bad header"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0xD8 { // SOI (Start Of Image).
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0xD8 { // SOI (Start Of Image).
|
||||
return "#bad header"
|
||||
}
|
||||
|
||||
@@ -367,17 +367,17 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
while true {
|
||||
// Read the marker (a two-byte 0xFF 0x?? sequence).
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0xFF {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0xFF {
|
||||
break
|
||||
}
|
||||
// Getting here is invalid according to the JPEG spec, but libjpeg
|
||||
// treats this as a warning (JWRN_EXTRANEOUS_DATA), not an error.
|
||||
} endwhile
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0xFF {
|
||||
marker = c
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0xFF {
|
||||
marker = c8
|
||||
break
|
||||
}
|
||||
// Section B.1.1.2: "Any marker may optionally be preceded by any
|
||||
@@ -500,20 +500,20 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
}
|
||||
|
||||
pri func decoder.decode_dqt?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var q : base.u8[..= 3]
|
||||
var i : base.u32
|
||||
var c8 : base.u8
|
||||
var q : base.u8[..= 3]
|
||||
var i : base.u32
|
||||
|
||||
while this.payload_length > 0 {
|
||||
this.payload_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if (c & 0x0F) > 3 {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 & 0x0F) > 3 {
|
||||
return "#bad DQT marker"
|
||||
}
|
||||
q = c & 0x0F
|
||||
if (c >> 4) == 1 {
|
||||
q = c8 & 0x0F
|
||||
if (c8 >> 4) == 1 {
|
||||
return "#unsupported precision"
|
||||
} else if ((c >> 4) > 1) or (this.payload_length < 64) {
|
||||
} else if ((c8 >> 4) > 1) or (this.payload_length < 64) {
|
||||
return "#bad DQT marker"
|
||||
}
|
||||
this.payload_length -= 64
|
||||
@@ -603,7 +603,7 @@ pri func decoder.decode_appn?(src: base.io_reader, marker: base.u8) {
|
||||
}
|
||||
|
||||
pri func decoder.decode_sof?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var comp_h : base.u8
|
||||
var comp_v : base.u8
|
||||
var i : base.u32
|
||||
@@ -627,12 +627,12 @@ pri func decoder.decode_sof?(src: base.io_reader) {
|
||||
return "#bad SOF marker"
|
||||
}
|
||||
this.payload_length -= 6
|
||||
c = args.src.read_u8?()
|
||||
if c == 8 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 8 {
|
||||
// No-op.
|
||||
} else if c == 12 {
|
||||
} else if c8 == 12 {
|
||||
return "#unsupported precision (12 bits)"
|
||||
} else if c == 16 {
|
||||
} else if c8 == 16 {
|
||||
return "#unsupported precision (16 bits)"
|
||||
} else {
|
||||
return "#unsupported precision"
|
||||
@@ -645,13 +645,13 @@ pri func decoder.decode_sof?(src: base.io_reader) {
|
||||
if this.width == 0 {
|
||||
return base."#unsupported image dimension"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if (c == 0) or (c > 4) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == 0) or (c8 > 4) {
|
||||
return "#bad SOF marker"
|
||||
} else if c == 2 {
|
||||
} else if c8 == 2 {
|
||||
return "#unsupported color model"
|
||||
}
|
||||
this.num_components = c as base.u32
|
||||
this.num_components = c8 as base.u32
|
||||
if this.payload_length <> (3 * this.num_components) {
|
||||
return "#bad SOF marker"
|
||||
}
|
||||
@@ -661,9 +661,9 @@ pri func decoder.decode_sof?(src: base.io_reader) {
|
||||
while i < this.num_components {
|
||||
assert i < 4 via "a < b: a < c; c <= b"(c: this.num_components)
|
||||
this.components_c[i] = args.src.read_u8?()
|
||||
c = args.src.read_u8?()
|
||||
comp_h = c >> 4
|
||||
comp_v = c & 0x0F
|
||||
c8 = args.src.read_u8?()
|
||||
comp_h = c8 >> 4
|
||||
comp_v = c8 & 0x0F
|
||||
if (comp_h == 0) or (comp_h > 4) or (comp_v == 0) or (comp_v > 4) {
|
||||
return "#bad SOF marker"
|
||||
}
|
||||
@@ -675,11 +675,11 @@ pri func decoder.decode_sof?(src: base.io_reader) {
|
||||
if this.max_incl_components_v < this.components_v[i] {
|
||||
this.max_incl_components_v = this.components_v[i]
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if c >= 4 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 >= 4 {
|
||||
return "#bad SOF marker"
|
||||
}
|
||||
this.components_tq[i] = c
|
||||
this.components_tq[i] = c8
|
||||
|
||||
// Section B.2.2: "the value of C_i shall be different from the values
|
||||
// of C_1 through C_(i-1)".
|
||||
@@ -902,7 +902,7 @@ 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 c : base.u8
|
||||
var c8 : base.u8
|
||||
var marker : base.u8
|
||||
|
||||
if this.call_sequence == 0x40 {
|
||||
@@ -948,17 +948,17 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
while true {
|
||||
// Read the marker (a two-byte 0xFF 0x?? sequence).
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0xFF {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0xFF {
|
||||
break
|
||||
}
|
||||
// Getting here is invalid according to the JPEG spec, but libjpeg
|
||||
// treats this as a warning (JWRN_EXTRANEOUS_DATA), not an error.
|
||||
} endwhile
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0xFF {
|
||||
marker = c
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0xFF {
|
||||
marker = c8
|
||||
break
|
||||
}
|
||||
// Section B.1.1.2: "Any marker may optionally be preceded by any
|
||||
@@ -1044,7 +1044,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
}
|
||||
|
||||
pri func decoder.decode_dht?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var tc : base.u8[..= 1]
|
||||
var th : base.u8[..= 3]
|
||||
var tc4_th : base.u8[..= 7]
|
||||
@@ -1061,12 +1061,12 @@ pri func decoder.decode_dht?(src: base.io_reader) {
|
||||
return "#bad DHT marker"
|
||||
}
|
||||
this.payload_length -= 17
|
||||
c = args.src.read_u8?()
|
||||
if ((c >> 4) > 1) or ((c & 0x0F) > 3) {
|
||||
c8 = args.src.read_u8?()
|
||||
if ((c8 >> 4) > 1) or ((c8 & 0x0F) > 3) {
|
||||
return "#bad DHT marker"
|
||||
}
|
||||
tc = c >> 4
|
||||
th = c & 0x0F
|
||||
tc = c8 >> 4
|
||||
th = c8 & 0x0F
|
||||
tc4_th = ((tc * 4) | th) as base.u8
|
||||
|
||||
// SOF0 (which is 0xC0) means a baseline JPEG. The baseline (th <= 1)
|
||||
@@ -1358,7 +1358,7 @@ pri func decoder.decode_sos?(src: base.io_reader, workbuf: slice base.u8) {
|
||||
}
|
||||
|
||||
pri func decoder.prepare_scan?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var i : base.u32
|
||||
var j : base.u32
|
||||
var j_max_incl : base.u32[..= 9]
|
||||
@@ -1367,11 +1367,11 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
|
||||
if (this.payload_length < 6) or (this.payload_length > 12) {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if (c < 1) or (c > 4) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 < 1) or (c8 > 4) {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
this.scan_num_components = c as base.u32
|
||||
this.scan_num_components = c8 as base.u32
|
||||
if (this.scan_num_components > this.num_components) or
|
||||
(this.payload_length <> (4 + (2 * this.scan_num_components))) {
|
||||
return "#bad SOS marker"
|
||||
@@ -1381,7 +1381,7 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
|
||||
i = 0
|
||||
while i < this.scan_num_components {
|
||||
assert i < 4 via "a < b: a < c; c <= b"(c: this.scan_num_components)
|
||||
c = args.src.read_u8?()
|
||||
c8 = args.src.read_u8?()
|
||||
|
||||
j = 0
|
||||
while true,
|
||||
@@ -1391,7 +1391,7 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
assert j < 4 via "a < b: a < c; c <= b"(c: this.num_components)
|
||||
if c == this.components_c[j] {
|
||||
if c8 == this.components_c[j] {
|
||||
if not this.seen_dqt[this.components_tq[j]] {
|
||||
return "#missing Quantization table"
|
||||
}
|
||||
@@ -1414,12 +1414,12 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
|
||||
j += 1
|
||||
} endwhile
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if ((c >> 4) > 3) or ((c & 0x0F) > 3) {
|
||||
c8 = args.src.read_u8?()
|
||||
if ((c8 >> 4) > 3) or ((c8 & 0x0F) > 3) {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
this.scan_comps_td[i] = c >> 4
|
||||
this.scan_comps_ta[i] = c & 0x0F
|
||||
this.scan_comps_td[i] = c8 >> 4
|
||||
this.scan_comps_ta[i] = c8 & 0x0F
|
||||
// SOF0 (which is 0xC0) means a baseline JPEG. The baseline (tx <= 1)
|
||||
// restriction is specified in table B.5.
|
||||
if this.sof_marker == 0xC0 {
|
||||
@@ -1442,24 +1442,24 @@ pri func decoder.prepare_scan?(src: base.io_reader) {
|
||||
this.scan_al = 0
|
||||
|
||||
} else {
|
||||
c = args.src.read_u8?()
|
||||
if c > 63 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 > 63 {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
this.scan_ss = c
|
||||
this.scan_ss = c8
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if (c > 63) or (c < this.scan_ss) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 > 63) or (c8 < this.scan_ss) {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
this.scan_se = c
|
||||
this.scan_se = c8
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if ((c >> 4) > 14) or ((c & 0x0F) > 13) {
|
||||
c8 = args.src.read_u8?()
|
||||
if ((c8 >> 4) > 14) or ((c8 & 0x0F) > 13) {
|
||||
return "#bad SOS marker"
|
||||
}
|
||||
this.scan_ah = c >> 4
|
||||
this.scan_al = c & 0x0F
|
||||
this.scan_ah = c8 >> 4
|
||||
this.scan_al = c8 & 0x0F
|
||||
if this.scan_ah > 0 {
|
||||
if (this.scan_ah - 1) <> this.scan_al {
|
||||
return "#bad SOS marker"
|
||||
@@ -1638,7 +1638,7 @@ pri func decoder.calculate_multiple_component_scan_fields!() base.bool {
|
||||
|
||||
pri func decoder.fill_bitstream!(src: base.io_reader) {
|
||||
var wi : base.u32[..= 0x800]
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var new_wi : base.u32[..= 0x800]
|
||||
|
||||
// Compact unread bytes to the start of the buffer.
|
||||
@@ -1657,9 +1657,9 @@ pri func decoder.fill_bitstream!(src: base.io_reader) {
|
||||
|
||||
wi = this.bitstream_wi
|
||||
while (wi < 0x800) and (args.src.length() > 0) {
|
||||
c = args.src.peek_u8()
|
||||
if c < 0xFF {
|
||||
this.bitstream_buffer[wi] = c
|
||||
c8 = args.src.peek_u8()
|
||||
if c8 < 0xFF {
|
||||
this.bitstream_buffer[wi] = c8
|
||||
wi += 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
continue
|
||||
@@ -1772,7 +1772,7 @@ pri func decoder.save_mcu_blocks!(mx: base.u32[..= 0x2000], my: base.u32[..= 0x2
|
||||
}
|
||||
|
||||
pri func decoder.skip_past_the_next_restart_marker?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
|
||||
while true {
|
||||
if args.src.length() < 2 {
|
||||
@@ -1783,24 +1783,24 @@ pri func decoder.skip_past_the_next_restart_marker?(src: base.io_reader) {
|
||||
continue
|
||||
}
|
||||
|
||||
c = (args.src.peek_u16le() >> 8) as base.u8
|
||||
if c < 0xC0 {
|
||||
c8 = (args.src.peek_u16le() >> 8) as base.u8
|
||||
if c8 < 0xC0 {
|
||||
// Either a reserved marker or "\xFF\x00" byte stuffing. Consume it
|
||||
// and continue.
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
continue
|
||||
} else if (c < 0xD0) or (0xD7 < c) {
|
||||
} else if (c8 < 0xD0) or (0xD7 < c8) {
|
||||
// Not an RSTn (Restart) marker. Leave it and break.
|
||||
break
|
||||
}
|
||||
|
||||
c &= 7
|
||||
if (this.next_restart_marker == ((c + 1) & 7)) or
|
||||
(this.next_restart_marker == ((c + 2) & 7)) {
|
||||
c8 &= 7
|
||||
if (this.next_restart_marker == ((c8 + 1) & 7)) or
|
||||
(this.next_restart_marker == ((c8 + 2) & 7)) {
|
||||
// A leading RSTn marker. Leave it and break.
|
||||
break
|
||||
} else if (this.next_restart_marker == ((c + 7) & 7)) or
|
||||
(this.next_restart_marker == ((c + 6) & 7)) {
|
||||
} else if (this.next_restart_marker == ((c8 + 7) & 7)) or
|
||||
(this.next_restart_marker == ((c8 + 6) & 7)) {
|
||||
// A lagging RSTn marker. Consume it and continue.
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
continue
|
||||
|
||||
+114
-114
@@ -103,8 +103,8 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
var stack_byte : base.u32[..= (1024 / 32) - 1]
|
||||
var stack_bit : base.u32[..= 31]
|
||||
var match : base.u32[..= 2]
|
||||
var c4 : base.u32
|
||||
var c : base.u8
|
||||
var c32 : base.u32
|
||||
var c8 : base.u8
|
||||
var backslash : base.u8
|
||||
var char : base.u8
|
||||
var class : base.u8[..= 0x0F]
|
||||
@@ -160,7 +160,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
|
||||
// Consume whitespace.
|
||||
whitespace_length = 0
|
||||
c = 0
|
||||
c8 = 0
|
||||
class = 0
|
||||
while.ws true,
|
||||
inv args.dst.length() > 0,
|
||||
@@ -182,8 +182,8 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
continue.outer
|
||||
}
|
||||
|
||||
c = args.src.peek_u8()
|
||||
class = LUT_CLASSES[c]
|
||||
c8 = args.src.peek_u8()
|
||||
class = LUT_CLASSES[c8]
|
||||
if class <> CLASS_WHITESPACE {
|
||||
break.ws
|
||||
}
|
||||
@@ -275,11 +275,11 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
inv args.dst.length() > 0,
|
||||
inv args.src.length() > 0,
|
||||
{
|
||||
c4 = args.src.peek_u32le()
|
||||
if 0x00 <> (LUT_CHARS[0xFF & (c4 >> 0)] |
|
||||
LUT_CHARS[0xFF & (c4 >> 8)] |
|
||||
LUT_CHARS[0xFF & (c4 >> 16)] |
|
||||
LUT_CHARS[0xFF & (c4 >> 24)]) {
|
||||
c32 = args.src.peek_u32le()
|
||||
if 0x00 <> (LUT_CHARS[0xFF & (c32 >> 0)] |
|
||||
LUT_CHARS[0xFF & (c32 >> 8)] |
|
||||
LUT_CHARS[0xFF & (c32 >> 16)] |
|
||||
LUT_CHARS[0xFF & (c32 >> 24)]) {
|
||||
break
|
||||
}
|
||||
args.src.skip_u32_fast!(actual: 4, worst_case: 4)
|
||||
@@ -298,8 +298,8 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
string_length += 4
|
||||
} endwhile
|
||||
|
||||
c = args.src.peek_u8()
|
||||
char = LUT_CHARS[c]
|
||||
c8 = args.src.peek_u8()
|
||||
char = LUT_CHARS[c8]
|
||||
|
||||
if char == 0x00 { // Non-special ASCII.
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
@@ -356,8 +356,8 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
yield? base."$short read"
|
||||
continue.string_loop_outer
|
||||
}
|
||||
c = (args.src.peek_u16le() >> 8) as base.u8
|
||||
backslash = LUT_BACKSLASHES[c]
|
||||
c8 = (args.src.peek_u16le() >> 8) as base.u8
|
||||
backslash = LUT_BACKSLASHES[c8]
|
||||
if (backslash & 0x80) <> 0 {
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
args.dst.write_simple_token_fast!(
|
||||
@@ -380,7 +380,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
continue.string_loop_outer
|
||||
}
|
||||
|
||||
} else if c == 'u' {
|
||||
} else if c8 == 'u' {
|
||||
// -------- BEGIN backslash-u.
|
||||
if args.src.length() < 6 {
|
||||
if args.src.is_closed() {
|
||||
@@ -394,18 +394,18 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
uni4_value = 0
|
||||
uni4_ok = 0x80
|
||||
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 0)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 12
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 8)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 8
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 16)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 4
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 24)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 0
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 0)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 12
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 8)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 8
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 16)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 4
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 24)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 0
|
||||
|
||||
if uni4_ok == 0 {
|
||||
// It wasn't 4 hexadecimal digits. No-op (and
|
||||
@@ -464,18 +464,18 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
uni4_ok = 0x80
|
||||
uni4_string >>= 16
|
||||
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 0)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 12
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 8)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 8
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 16)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 4
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 24)]
|
||||
uni4_ok &= c
|
||||
uni4_value |= ((c & 0x0F) as base.u32) << 0
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 0)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 12
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 8)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 8
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 16)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 4
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni4_string >> 24)]
|
||||
uni4_ok &= c8
|
||||
uni4_value |= ((c8 & 0x0F) as base.u32) << 0
|
||||
}
|
||||
|
||||
if (uni4_ok <> 0) and
|
||||
@@ -510,7 +510,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
}
|
||||
// -------- END backslash-u.
|
||||
|
||||
} else if (c == 'U') and
|
||||
} else if (c8 == 'U') and
|
||||
this.quirks[QUIRK_ALLOW_BACKSLASH_CAPITAL_U - QUIRKS_BASE] {
|
||||
// -------- BEGIN backslash-capital-u.
|
||||
if args.src.length() < 10 {
|
||||
@@ -524,30 +524,30 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
uni8_value = 0
|
||||
uni8_ok = 0x80
|
||||
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 0)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 28
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 8)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 24
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 16)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 20
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 24)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 16
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 32)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 12
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 40)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 8
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 48)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 4
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 56)]
|
||||
uni8_ok &= c
|
||||
uni8_value |= ((c & 0x0F) as base.u32) << 0
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 0)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 28
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 8)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 24
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 16)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 20
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 24)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 16
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 32)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 12
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 40)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 8
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 48)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 4
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (uni8_string >> 56)]
|
||||
uni8_ok &= c8
|
||||
uni8_value |= ((c8 & 0x0F) as base.u32) << 0
|
||||
|
||||
if uni8_ok == 0 {
|
||||
// It wasn't 8 hexadecimal digits. No-op (and
|
||||
@@ -576,7 +576,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
}
|
||||
// -------- END backslash-capital-u.
|
||||
|
||||
} else if (c == 'x') and
|
||||
} else if (c8 == 'x') and
|
||||
this.quirks[QUIRK_ALLOW_BACKSLASH_X_AS_CODE_POINTS - QUIRKS_BASE] {
|
||||
// -------- BEGIN backslash-x
|
||||
if args.src.length() < 4 {
|
||||
@@ -590,12 +590,12 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
backslash_x_string = args.src.peek_u32le()
|
||||
backslash_x_ok = 0x80
|
||||
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 16)]
|
||||
backslash_x_ok &= c
|
||||
backslash_x_value = ((c & 0x0F) << 4) as base.u8
|
||||
c = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 24)]
|
||||
backslash_x_ok &= c
|
||||
backslash_x_value = (backslash_x_value | (c & 0x0F)) as base.u8
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 16)]
|
||||
backslash_x_ok &= c8
|
||||
backslash_x_value = ((c8 & 0x0F) << 4) as base.u8
|
||||
c8 = LUT_HEXADECIMAL_DIGITS[0xFF & (backslash_x_string >> 24)]
|
||||
backslash_x_ok &= c8
|
||||
backslash_x_value = (backslash_x_value | (c8 & 0x0F)) as base.u8
|
||||
|
||||
if (backslash_x_ok == 0) or
|
||||
((backslash_x_string & 0xFFFF) <> 0x785C) {
|
||||
@@ -1204,7 +1204,7 @@ pub func decoder.decode_tokens?(dst: base.token_writer, src: base.io_reader, wor
|
||||
}
|
||||
|
||||
pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var n : base.u32[..= 0x3FF]
|
||||
var floating_point : base.u32[..= 0x80]
|
||||
|
||||
@@ -1218,10 +1218,10 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
}
|
||||
break.goto_done
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
|
||||
// Scan the optional minus sign.
|
||||
if c <> '-' {
|
||||
if c8 <> '-' {
|
||||
assert args.src.length() > 0
|
||||
assert n <= 1
|
||||
} else {
|
||||
@@ -1236,14 +1236,14 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
n |= 0x100 // A '-' without digits is invalid.
|
||||
break.goto_done
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
|
||||
assert args.src.length() > 0
|
||||
assert n <= 1
|
||||
}
|
||||
|
||||
// Scan the opening digits.
|
||||
if c == '0' {
|
||||
if c8 == '0' {
|
||||
n += 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
assert n <= 99
|
||||
@@ -1262,10 +1262,10 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
}
|
||||
break.goto_done
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
|
||||
// Scan the optional fraction.
|
||||
if c <> '.' {
|
||||
if c8 <> '.' {
|
||||
assert args.src.length() > 0
|
||||
assert n <= 99
|
||||
} else {
|
||||
@@ -1289,14 +1289,14 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
}
|
||||
break.goto_done
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
|
||||
assert args.src.length() > 0
|
||||
assert n <= 99
|
||||
}
|
||||
|
||||
// Scan the optional 'E' or 'e'.
|
||||
if (c <> 'E') and (c <> 'e') {
|
||||
if (c8 <> 'E') and (c8 <> 'e') {
|
||||
break.goto_done
|
||||
}
|
||||
if n >= 99 {
|
||||
@@ -1316,10 +1316,10 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
n |= 0x100 // An 'E' or 'e' without digits is invalid.
|
||||
break.goto_done
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
|
||||
// Scan the optional '+' or '-'.
|
||||
if (c <> '+') and (c <> '-') {
|
||||
if (c8 <> '+') and (c8 <> '-') {
|
||||
assert n <= 99
|
||||
} else {
|
||||
if n >= 99 {
|
||||
@@ -1341,8 +1341,8 @@ pri func decoder.decode_number!(src: base.io_reader) base.u32[..= 0x3FF] {
|
||||
}
|
||||
|
||||
pri func decoder.decode_digits!(src: base.io_reader, n: base.u32[..= 99]) base.u32[..= 0x3FF] {
|
||||
var c : base.u8
|
||||
var n : base.u32[..= 0x3FF]
|
||||
var c8 : base.u8
|
||||
var n : base.u32[..= 0x3FF]
|
||||
|
||||
n = args.n
|
||||
while true {
|
||||
@@ -1352,8 +1352,8 @@ pri func decoder.decode_digits!(src: base.io_reader, n: base.u32[..= 99]) base.u
|
||||
}
|
||||
break
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
if 0x00 == LUT_DECIMAL_DIGITS[c] {
|
||||
c8 = args.src.peek_u8()
|
||||
if 0x00 == LUT_DECIMAL_DIGITS[c8] {
|
||||
break
|
||||
}
|
||||
// Cap DECODER_NUMBER_LENGTH_MAX_INCL at an arbitrary value, 99. The
|
||||
@@ -1379,8 +1379,8 @@ pri func decoder.decode_digits!(src: base.io_reader, n: base.u32[..= 99]) base.u
|
||||
}
|
||||
|
||||
pri func decoder.decode_leading?(dst: base.token_writer, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var u : base.u32
|
||||
var c8 : base.u8
|
||||
var u : base.u32
|
||||
|
||||
this.allow_leading_ars =
|
||||
this.quirks[QUIRK_ALLOW_LEADING_ASCII_RECORD_SEPARATOR - QUIRKS_BASE]
|
||||
@@ -1399,14 +1399,14 @@ pri func decoder.decode_leading?(dst: base.token_writer, src: base.io_reader) {
|
||||
yield? base."$short read"
|
||||
continue
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
if (c == 0x1E) and this.allow_leading_ars {
|
||||
c8 = args.src.peek_u8()
|
||||
if (c8 == 0x1E) and this.allow_leading_ars {
|
||||
this.allow_leading_ars = false
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0, value_minor: 0, continued: 0, length: 1)
|
||||
continue
|
||||
} else if (c == 0xEF) and this.allow_leading_ubom {
|
||||
} else if (c8 == 0xEF) and this.allow_leading_ubom {
|
||||
if args.src.length() < 3 {
|
||||
if args.src.is_closed() {
|
||||
break
|
||||
@@ -1428,8 +1428,8 @@ pri func decoder.decode_leading?(dst: base.token_writer, src: base.io_reader) {
|
||||
}
|
||||
|
||||
pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c2 : base.u16
|
||||
var c8 : base.u8
|
||||
var c16 : base.u16
|
||||
var length : base.u32[..= 0xFFFD]
|
||||
|
||||
this.comment_type = 0
|
||||
@@ -1447,9 +1447,9 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
}
|
||||
yield? base."$short read"
|
||||
} endwhile
|
||||
c2 = args.src.peek_u16le()
|
||||
c16 = args.src.peek_u16le()
|
||||
|
||||
if (c2 == '/*'le) and this.quirks[QUIRK_ALLOW_COMMENT_BLOCK - QUIRKS_BASE] {
|
||||
if (c16 == '/*'le) and this.quirks[QUIRK_ALLOW_COMMENT_BLOCK - QUIRKS_BASE] {
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
length = 2
|
||||
|
||||
@@ -1478,8 +1478,8 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
continue.comment_block
|
||||
}
|
||||
|
||||
c2 = args.src.peek_u16le()
|
||||
if c2 == '*/'le {
|
||||
c16 = args.src.peek_u16le()
|
||||
if c16 == '*/'le {
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
@@ -1510,7 +1510,7 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
length += 1
|
||||
} endwhile.comment_block
|
||||
|
||||
} else if (c2 == '//'le) and this.quirks[QUIRK_ALLOW_COMMENT_LINE - QUIRKS_BASE] {
|
||||
} else if (c16 == '//'le) and this.quirks[QUIRK_ALLOW_COMMENT_LINE - QUIRKS_BASE] {
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
length = 2
|
||||
|
||||
@@ -1545,8 +1545,8 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
continue.comment_line
|
||||
}
|
||||
|
||||
c = args.src.peek_u8()
|
||||
if c == '\n' {
|
||||
c8 = args.src.peek_u8()
|
||||
if c8 == '\n' {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
value_minor: (base.TOKEN__VBC__FILLER << 21) |
|
||||
@@ -1579,7 +1579,7 @@ pri func decoder.decode_comment?(dst: base.token_writer, src: base.io_reader) {
|
||||
}
|
||||
|
||||
pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
var c4 : base.u32
|
||||
var c32 : base.u32
|
||||
var neg : base.u32[..= 1]
|
||||
|
||||
while true {
|
||||
@@ -1597,8 +1597,8 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
|
||||
// Bitwise or'ing with 0x20 converts upper case ASCII to lower case.
|
||||
|
||||
c4 = args.src.peek_u24le_as_u32()
|
||||
if (c4 | 0x20_2020) == 'inf'le {
|
||||
c32 = args.src.peek_u24le_as_u32()
|
||||
if (c32 | 0x20_2020) == 'inf'le {
|
||||
if args.src.length() > 7 {
|
||||
if (args.src.peek_u64le() | 0x2020_2020_2020_2020) == 'infinity'le {
|
||||
args.dst.write_simple_token_fast!(
|
||||
@@ -1623,7 +1623,7 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
args.src.skip_u32_fast!(actual: 3, worst_case: 3)
|
||||
return ok
|
||||
|
||||
} else if (c4 | 0x20_2020) == 'nan'le {
|
||||
} else if (c32 | 0x20_2020) == 'nan'le {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
value_minor: (base.TOKEN__VBC__NUMBER << 21) |
|
||||
@@ -1632,9 +1632,9 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
length: 3)
|
||||
args.src.skip_u32_fast!(actual: 3, worst_case: 3)
|
||||
return ok
|
||||
} else if (c4 & 0xFF) == '+' {
|
||||
} else if (c32 & 0xFF) == '+' {
|
||||
neg = 0
|
||||
} else if (c4 & 0xFF) == '-' {
|
||||
} else if (c32 & 0xFF) == '-' {
|
||||
neg = 1
|
||||
} else {
|
||||
return "#bad input"
|
||||
@@ -1648,8 +1648,8 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
continue
|
||||
}
|
||||
|
||||
c4 = args.src.peek_u32le() >> 8
|
||||
if (c4 | 0x20_2020) == 'inf'le {
|
||||
c32 = args.src.peek_u32le() >> 8
|
||||
if (c32 | 0x20_2020) == 'inf'le {
|
||||
if args.src.length() > 8 {
|
||||
if (args.src.peek_u64le_at(offset: 1) | 0x2020_2020_2020_2020) == 'infinity'le {
|
||||
args.dst.write_simple_token_fast!(
|
||||
@@ -1674,7 +1674,7 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
args.src.skip_u32_fast!(actual: 4, worst_case: 4)
|
||||
return ok
|
||||
|
||||
} else if (c4 | 0x20_2020) == 'nan'le {
|
||||
} else if (c32 | 0x20_2020) == 'nan'le {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0,
|
||||
value_minor: (base.TOKEN__VBC__NUMBER << 21) |
|
||||
@@ -1690,7 +1690,7 @@ pri func decoder.decode_inf_nan?(dst: base.token_writer, src: base.io_reader) {
|
||||
}
|
||||
|
||||
pri func decoder.decode_trailer?(dst: base.token_writer, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
var whitespace_length : base.u32[..= 0xFFFE]
|
||||
|
||||
if this.quirks[QUIRK_EXPECT_TRAILING_NEW_LINE_OR_EOF - QUIRKS_BASE] {
|
||||
@@ -1721,8 +1721,8 @@ pri func decoder.decode_trailer?(dst: base.token_writer, src: base.io_reader) {
|
||||
continue.outer
|
||||
}
|
||||
|
||||
c = args.src.peek_u8()
|
||||
if LUT_CLASSES[c] <> CLASS_WHITESPACE {
|
||||
c8 = args.src.peek_u8()
|
||||
if LUT_CLASSES[c8] <> CLASS_WHITESPACE {
|
||||
if whitespace_length > 0 {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0, value_minor: 0, continued: 0, length: whitespace_length)
|
||||
@@ -1738,10 +1738,10 @@ pri func decoder.decode_trailer?(dst: base.token_writer, src: base.io_reader) {
|
||||
}
|
||||
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
if (whitespace_length >= 0xFFFE) or (c == this.trailer_stop) {
|
||||
if (whitespace_length >= 0xFFFE) or (c8 == this.trailer_stop) {
|
||||
args.dst.write_simple_token_fast!(
|
||||
value_major: 0, value_minor: 0, continued: 0, length: whitespace_length + 1)
|
||||
if c == this.trailer_stop {
|
||||
if c8 == this.trailer_stop {
|
||||
return ok
|
||||
}
|
||||
continue.outer
|
||||
|
||||
@@ -57,62 +57,62 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var n : base.u32
|
||||
var c8 : base.u8
|
||||
var n : base.u32
|
||||
|
||||
if this.call_sequence <> 0x00 {
|
||||
return base."#bad call sequence"
|
||||
}
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if c <> 'P' {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 'P' {
|
||||
return "#bad header"
|
||||
}
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if (c < '1') or ('7' < c) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 < '1') or ('7' < c8) {
|
||||
return "#bad header"
|
||||
} else if c == '5' {
|
||||
} else if c8 == '5' {
|
||||
this.pixfmt = base.PIXEL_FORMAT__Y
|
||||
} else if c == '6' {
|
||||
} else if c8 == '6' {
|
||||
this.pixfmt = base.PIXEL_FORMAT__RGB
|
||||
} else {
|
||||
return "#unsupported Netpbm file"
|
||||
}
|
||||
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0x0A {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0x0A {
|
||||
return "#bad header"
|
||||
}
|
||||
|
||||
// Decode width.
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if (c == ' ') or (c == 0x09) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == ' ') or (c8 == 0x09) {
|
||||
continue
|
||||
} else if c == '#' {
|
||||
} else if c8 == '#' {
|
||||
// Consume a "#...\n" comment.
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0x0A {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0x0A {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
continue
|
||||
} else if (c < '0') or ('9' < c) {
|
||||
} else if (c8 < '0') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
this.width = ((c - '0') as base.u32)
|
||||
this.width = ((c8 - '0') as base.u32)
|
||||
break
|
||||
} endwhile
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if (c == ' ') or (c == 0x09) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == ' ') or (c8 == 0x09) {
|
||||
break
|
||||
} else if (c < '0') or ('9' < c) {
|
||||
} else if (c8 < '0') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
n = (10 * this.width) + ((c - '0') as base.u32)
|
||||
n = (10 * this.width) + ((c8 - '0') as base.u32)
|
||||
if n > 0xFF_FFFF {
|
||||
return "#unsupported Netpbm file"
|
||||
}
|
||||
@@ -121,34 +121,34 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
|
||||
// Decode height.
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if (c == ' ') or (c == 0x09) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == ' ') or (c8 == 0x09) {
|
||||
continue
|
||||
} else if c == '#' {
|
||||
} else if c8 == '#' {
|
||||
// Consume a "#...\n" comment.
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0x0A {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0x0A {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
continue
|
||||
} else if (c < '0') or ('9' < c) {
|
||||
} else if (c8 < '0') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
this.height = ((c - '0') as base.u32)
|
||||
this.height = ((c8 - '0') as base.u32)
|
||||
break
|
||||
} endwhile
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if (c == ' ') or (c == 0x09) or (c == 0x0D) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == ' ') or (c8 == 0x09) or (c8 == 0x0D) {
|
||||
continue
|
||||
} else if c == 0x0A {
|
||||
} else if c8 == 0x0A {
|
||||
break
|
||||
} else if (c < '0') or ('9' < c) {
|
||||
} else if (c8 < '0') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
n = (10 * this.height) + ((c - '0') as base.u32)
|
||||
n = (10 * this.height) + ((c8 - '0') as base.u32)
|
||||
if n > 0xFF_FFFF {
|
||||
return "#unsupported Netpbm file"
|
||||
}
|
||||
@@ -157,34 +157,34 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
|
||||
// Decode max_value.
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if (c == ' ') or (c == 0x09) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == ' ') or (c8 == 0x09) {
|
||||
continue
|
||||
} else if c == '#' {
|
||||
} else if c8 == '#' {
|
||||
// Consume a "#...\n" comment.
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if c == 0x0A {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0x0A {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
continue
|
||||
} else if (c < '0') or ('9' < c) {
|
||||
} else if (c8 < '0') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
this.max_value = ((c - '0') as base.u32)
|
||||
this.max_value = ((c8 - '0') as base.u32)
|
||||
break
|
||||
} endwhile
|
||||
while true {
|
||||
c = args.src.read_u8?()
|
||||
if (c == ' ') or (c == 0x09) or (c == 0x0D) {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 == ' ') or (c8 == 0x09) or (c8 == 0x0D) {
|
||||
continue
|
||||
} else if c == 0x0A {
|
||||
} else if c8 == 0x0A {
|
||||
break
|
||||
} else if (c < '0') or ('9' < c) {
|
||||
} else if (c8 < '0') or ('9' < c8) {
|
||||
return "#bad header"
|
||||
}
|
||||
n = (10 * this.max_value) + ((c - '0') as base.u32)
|
||||
n = (10 * this.max_value) + ((c8 - '0') as base.u32)
|
||||
if n > 0xFF_FFFF {
|
||||
return "#unsupported Netpbm file"
|
||||
}
|
||||
|
||||
+30
-30
@@ -790,7 +790,7 @@ pri func decoder.decode_gama?(src: base.io_reader) {
|
||||
}
|
||||
|
||||
pri func decoder.decode_iccp?(src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
|
||||
// Skip the NUL-terminated color profile name.
|
||||
while true {
|
||||
@@ -798,8 +798,8 @@ pri func decoder.decode_iccp?(src: base.io_reader) {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0 {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
@@ -809,8 +809,8 @@ pri func decoder.decode_iccp?(src: base.io_reader) {
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0 {
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
|
||||
@@ -1426,8 +1426,8 @@ pub func decoder.tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inform
|
||||
}
|
||||
|
||||
pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_information, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var c2 : base.u16
|
||||
var c8 : base.u8
|
||||
var c16 : base.u16
|
||||
var w : base.io_writer
|
||||
var num_written : base.u64
|
||||
var w_mark : base.u64
|
||||
@@ -1548,23 +1548,23 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
// Drain this.dst_palette, converting from Latin-1 to UTF-8.
|
||||
while this.ztxt_ri < this.ztxt_wi {
|
||||
assert this.ztxt_ri < 1024 via "a < b: a < c; c <= b"(c: this.ztxt_wi)
|
||||
c2 = LATIN_1[this.dst_palette[this.ztxt_ri]]
|
||||
if c2 == 0 {
|
||||
c16 = LATIN_1[this.dst_palette[this.ztxt_ri]]
|
||||
if c16 == 0 {
|
||||
return "#bad text chunk (not Latin-1)"
|
||||
} else if c2 <= 0x7F {
|
||||
} else if c16 <= 0x7F {
|
||||
if args.dst.length() <= 0 {
|
||||
yield? base."$short write"
|
||||
continue.loop
|
||||
}
|
||||
this.ztxt_ri += 1
|
||||
args.dst.write_u8_fast!(a: c2 as base.u8)
|
||||
args.dst.write_u8_fast!(a: c16 as base.u8)
|
||||
} else {
|
||||
if args.dst.length() <= 1 {
|
||||
yield? base."$short write"
|
||||
continue.loop
|
||||
}
|
||||
this.ztxt_ri += 1
|
||||
args.dst.write_u16le_fast!(a: c2)
|
||||
args.dst.write_u16le_fast!(a: c16)
|
||||
}
|
||||
} endwhile
|
||||
|
||||
@@ -1596,9 +1596,9 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
continue.loop
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_u8_fast!(a: c)
|
||||
args.dst.write_u8_fast!(a: c8)
|
||||
} endwhile
|
||||
|
||||
} else {
|
||||
@@ -1614,23 +1614,23 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
yield? base."$short read"
|
||||
continue.loop
|
||||
}
|
||||
c = args.src.peek_u8()
|
||||
if c == 0 {
|
||||
c8 = args.src.peek_u8()
|
||||
if c8 == 0 {
|
||||
this.chunk_length -= 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
break.loop
|
||||
}
|
||||
c2 = LATIN_1[c]
|
||||
if c2 == 0 {
|
||||
c16 = LATIN_1[c8]
|
||||
if c16 == 0 {
|
||||
return "#bad text chunk (not Latin-1)"
|
||||
} else if c2 <= 0x7F {
|
||||
} else if c16 <= 0x7F {
|
||||
if args.dst.length() <= 0 {
|
||||
yield? base."$short write"
|
||||
continue.loop
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_u8_fast!(a: c2 as base.u8)
|
||||
args.dst.write_u8_fast!(a: c16 as base.u8)
|
||||
} else {
|
||||
if args.dst.length() <= 1 {
|
||||
yield? base."$short write"
|
||||
@@ -1638,7 +1638,7 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
args.dst.write_u16le_fast!(a: c2)
|
||||
args.dst.write_u16le_fast!(a: c16)
|
||||
}
|
||||
} endwhile
|
||||
}
|
||||
@@ -1653,16 +1653,16 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 2
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0 {
|
||||
this.metadata_is_zlib_compressed = false
|
||||
} else if c == 1 {
|
||||
} else if c8 == 1 {
|
||||
this.metadata_is_zlib_compressed = true
|
||||
} else {
|
||||
return "#bad chunk"
|
||||
}
|
||||
c = args.src.read_u8?()
|
||||
if (c <> 0) and this.metadata_is_zlib_compressed {
|
||||
c8 = args.src.read_u8?()
|
||||
if (c8 <> 0) and this.metadata_is_zlib_compressed {
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
|
||||
@@ -1676,8 +1676,8 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c == 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 == 0 {
|
||||
break
|
||||
}
|
||||
} endwhile
|
||||
@@ -1689,8 +1689,8 @@ pri func decoder.do_tell_me_more?(dst: base.io_writer, minfo: nptr base.more_inf
|
||||
return "#bad chunk"
|
||||
}
|
||||
this.chunk_length -= 1
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0 {
|
||||
return "#unsupported PNG compression method"
|
||||
}
|
||||
this.metadata_is_zlib_compressed = true
|
||||
|
||||
+25
-25
@@ -69,9 +69,9 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
|
||||
var c : base.u32
|
||||
var c5 : base.u32[..= 0x1F]
|
||||
var i : base.u32
|
||||
var c32 : base.u32
|
||||
var c5 : base.u32[..= 0x1F]
|
||||
var i : base.u32
|
||||
|
||||
if this.call_sequence <> 0x00 {
|
||||
return base."#bad call sequence"
|
||||
@@ -190,25 +190,25 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
while i < (this.header_color_map_length as base.u32) {
|
||||
assert i <= 0xFFFF via "a <= b: a <= c; c <= b"(c: this.header_color_map_length as base.u32)
|
||||
if this.header_color_map_entry_size == 0x18 {
|
||||
c = args.src.read_u24le_as_u32?()
|
||||
this.src_palette[((i & 0xFF) * 4) + 0] = ((c >> 0x00) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 1] = ((c >> 0x08) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 2] = ((c >> 0x10) & 0xFF) as base.u8
|
||||
c32 = args.src.read_u24le_as_u32?()
|
||||
this.src_palette[((i & 0xFF) * 4) + 0] = ((c32 >> 0x00) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 1] = ((c32 >> 0x08) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 2] = ((c32 >> 0x10) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 3] = 0xFF
|
||||
} else if this.header_color_map_entry_size == 0x20 {
|
||||
c = args.src.read_u32le?()
|
||||
this.src_palette[((i & 0xFF) * 4) + 0] = ((c >> 0x00) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 1] = ((c >> 0x08) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 2] = ((c >> 0x10) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 3] = ((c >> 0x18) & 0xFF) as base.u8
|
||||
c32 = args.src.read_u32le?()
|
||||
this.src_palette[((i & 0xFF) * 4) + 0] = ((c32 >> 0x00) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 1] = ((c32 >> 0x08) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 2] = ((c32 >> 0x10) & 0xFF) as base.u8
|
||||
this.src_palette[((i & 0xFF) * 4) + 3] = ((c32 >> 0x18) & 0xFF) as base.u8
|
||||
} else {
|
||||
// Expand 15-bit or 16-bit color map entries.
|
||||
c = args.src.read_u16le_as_u32?()
|
||||
c5 = 0x1F & (c >> 0)
|
||||
c32 = args.src.read_u16le_as_u32?()
|
||||
c5 = 0x1F & (c32 >> 0)
|
||||
this.src_palette[((i & 0xFF) * 4) + 0] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
c5 = 0x1F & (c >> 5)
|
||||
c5 = 0x1F & (c32 >> 5)
|
||||
this.src_palette[((i & 0xFF) * 4) + 1] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
c5 = 0x1F & (c >> 10)
|
||||
c5 = 0x1F & (c32 >> 10)
|
||||
this.src_palette[((i & 0xFF) * 4) + 2] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
// TODO: can the alpha value be zero (BGRA5551 not BGRX5551)?
|
||||
this.src_palette[((i & 0xFF) * 4) + 3] = 0xFF
|
||||
@@ -316,7 +316,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
var run_length : base.u32[..= 0xFFFF]
|
||||
var num_dst_bytes : base.u64[..= 0x1F_FFE0]
|
||||
var num_src_bytes : base.u32[..= 0x3_FFFC]
|
||||
var c : base.u32
|
||||
var c32 : base.u32
|
||||
var c5 : base.u32[..= 0x1F]
|
||||
|
||||
if this.call_sequence == 0x40 {
|
||||
@@ -477,13 +477,13 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
yield? base."$short read"
|
||||
continue.resume
|
||||
}
|
||||
c = args.src.peek_u16le_as_u32()
|
||||
c32 = args.src.peek_u16le_as_u32()
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
c5 = 0x1F & (c >> 0)
|
||||
c5 = 0x1F & (c32 >> 0)
|
||||
this.scratch[0] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
c5 = 0x1F & (c >> 5)
|
||||
c5 = 0x1F & (c32 >> 5)
|
||||
this.scratch[1] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
c5 = 0x1F & (c >> 10)
|
||||
c5 = 0x1F & (c32 >> 10)
|
||||
this.scratch[2] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
// TODO: can the alpha value be zero (BGRA5551 not BGRX5551)?
|
||||
this.scratch[3] = 0xFF
|
||||
@@ -528,13 +528,13 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
}
|
||||
run_length = (args.src.peek_u8_as_u32() & 0x7F) + 1
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
c = args.src.peek_u16le_as_u32()
|
||||
c32 = args.src.peek_u16le_as_u32()
|
||||
args.src.skip_u32_fast!(actual: 2, worst_case: 2)
|
||||
c5 = 0x1F & (c >> 0)
|
||||
c5 = 0x1F & (c32 >> 0)
|
||||
this.scratch[0] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
c5 = 0x1F & (c >> 5)
|
||||
c5 = 0x1F & (c32 >> 5)
|
||||
this.scratch[1] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
c5 = 0x1F & (c >> 10)
|
||||
c5 = 0x1F & (c32 >> 10)
|
||||
this.scratch[2] = ((c5 << 3) | (c5 >> 2)) as base.u8
|
||||
// TODO: can the alpha value be zero (BGRA5551 not BGRX5551)?
|
||||
this.scratch[3] = 0xFF
|
||||
|
||||
+13
-13
@@ -48,9 +48,9 @@ pub func decoder.decode_image_config?(dst: nptr base.image_config, src: base.io_
|
||||
}
|
||||
|
||||
pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.io_reader) {
|
||||
var c : base.u8
|
||||
var i : base.u32
|
||||
var p : base.u32[..= 0xFF_FFFF]
|
||||
var c8 : base.u8
|
||||
var i : base.u32
|
||||
var p : base.u32[..= 0xFF_FFFF]
|
||||
|
||||
if this.call_sequence <> 0x00 {
|
||||
return base."#bad call sequence"
|
||||
@@ -59,8 +59,8 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
// TypeField, FixHeaderField.
|
||||
i = 0
|
||||
while i < 2 {
|
||||
c = args.src.read_u8?()
|
||||
if c <> 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
if c8 <> 0 {
|
||||
return "#bad header"
|
||||
}
|
||||
i += 1
|
||||
@@ -74,9 +74,9 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
|
||||
while true,
|
||||
inv i < 2,
|
||||
{
|
||||
c = args.src.read_u8?()
|
||||
p |= (c & 0x7F) as base.u32
|
||||
if (c >> 7) == 0 {
|
||||
c8 = args.src.read_u8?()
|
||||
p |= (c8 & 0x7F) as base.u32
|
||||
if (c8 >> 7) == 0 {
|
||||
break
|
||||
} else if p > 0x1_FFFF {
|
||||
return base."#unsupported image dimension"
|
||||
@@ -176,7 +176,7 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
var tab : table base.u8
|
||||
var dst : slice base.u8
|
||||
var src : array[1] base.u8
|
||||
var c : base.u8
|
||||
var c8 : base.u8
|
||||
|
||||
if this.call_sequence == 0x40 {
|
||||
// No-op.
|
||||
@@ -232,20 +232,20 @@ pri func decoder.do_decode_frame?(dst: ptr base.pixel_buffer, src: base.io_reade
|
||||
dst = dst[dst_x_in_bytes ..]
|
||||
}
|
||||
} endwhile
|
||||
c = args.src.peek_u8()
|
||||
c8 = args.src.peek_u8()
|
||||
args.src.skip_u32_fast!(actual: 1, worst_case: 1)
|
||||
}
|
||||
if (c & 0x80) == 0 {
|
||||
if (c8 & 0x80) == 0 {
|
||||
src[0] = 0x00
|
||||
} else {
|
||||
src[0] = 0xFF
|
||||
}
|
||||
// TODO: this should just be "c ~mod<<= 1", but that generates:
|
||||
// TODO: this should just be "c8 ~mod<<= 1", but that generates:
|
||||
//
|
||||
// error: conversion to ‘uint8_t {aka unsigned char}’ from
|
||||
// ‘int’ may alter its value [-Werror=conversion]
|
||||
// v_c <<= 1;
|
||||
c = (((c as base.u32) << 1) & 0xFF) as base.u8
|
||||
c8 = (((c8 as base.u32) << 1) & 0xFF) as base.u8
|
||||
|
||||
this.swizzler.swizzle_interleaved_from_slice!(
|
||||
dst: dst, dst_palette: this.util.empty_slice_u8(), src: src[..])
|
||||
|
||||
Reference in new issue
Block a user