std/etc2: support ETC2PACKAGE_RGB_NO_MIPMAPS

This commit is contained in:
Nigel Tao committed 2024-08-18 09:42:22 +10:00
1 parent 43df015669
commit 7637982814
3 files changed
+541 -8

No files matched your search

+302 -4
View File
@@ -47,6 +47,8 @@ pub struct decoder? implements base.image_decoder(
// (/doc/std/image-decoders-call-sequence.md).
call_sequence : base.u8,
srgb : base.bool,
// buffer_index is measured in blocks.
buffer_index : base.u32[..= 64],
@@ -95,13 +97,16 @@ pri func decoder.do_decode_image_config?(dst: nptr base.image_config, src: base.
}
c32 = args.src.read_u32le?()
if c32 == '10\x00\x00'le {
if (c32 == '10\x00\x00'le) or // ETC1.
(c32 == '20\x00\x01'le) or // ETC2 RGB.
(c32 == '20\x00\x09'le) { // ETC2 sRGB.
this.pixfmt = base.PIXEL_FORMAT__BGRX
} else if (c32 & 0xFFFF) == '20'le {
return "#unsupported ETC2 file"
} else {
return "#bad header"
}
this.srgb = (c32 >> 24) >= 0x09
rounded_up_width = args.src.read_u16be?()
rounded_up_height = args.src.read_u16be?()
@@ -248,6 +253,12 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
c64 = args.src.read_u64be?()
if (c64 & 0x2_0000_0000) == 0 {
// The high 32 bits of c64:
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec
// 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex
// R0 r0 r0 r0 R1 r1 r1 r1 G0 g0 g0 g0 G1 g1 g1 g1 B0 b0 b0 b0 B1 b1 b1 b1 W0 w0 w0 W1 w1 w1 00 Fl
r0 = (0x0F & (c64 >> 0x3C)) as base.u32
r0 = (r0 << 4) | r0
r1 = (0x0F & (c64 >> 0x38)) as base.u32
@@ -264,18 +275,45 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
b1 = (b1 << 4) | b1
} else {
// The high 32 bits of c64 (unless ETC2's T / H / Planar modes):
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec
// 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex
// R0 r0 r0 r0 r0 R1 r1 r1 G0 g0 g0 g0 g0 G1 g1 g1 B0 b0 b0 b0 b0 B1 b1 b1 W0 w0 w0 W1 w1 w1 01 Fl
r0 = (0x1F & (c64 >> 0x3B)) as base.u32
r1 = (0x1F & (r0 ~mod+ DIFFS[0x07 & (c64 >> 0x38)]))
r1 = r0 ~mod+ DIFFS[0x07 & (c64 >> 0x38)]
if (r1 >> 5) <> 0 {
this.decode_t_mode!(
bits: c64,
offset: 16 * bi)
bi += 1
continue
}
r0 = (r0 ~mod<< 3) | (r0 >> 2)
r1 = (r1 ~mod<< 3) | (r1 >> 2)
g0 = (0x1F & (c64 >> 0x33)) as base.u32
g1 = (0x1F & (g0 ~mod+ DIFFS[0x07 & (c64 >> 0x30)]))
g1 = g0 ~mod+ DIFFS[0x07 & (c64 >> 0x30)]
if (g1 >> 5) <> 0 {
this.decode_h_mode!(
bits: c64,
offset: 16 * bi)
bi += 1
continue
}
g0 = (g0 ~mod<< 3) | (g0 >> 2)
g1 = (g1 ~mod<< 3) | (g1 >> 2)
b0 = (0x1F & (c64 >> 0x2B)) as base.u32
b1 = (0x1F & (b0 ~mod+ DIFFS[0x07 & (c64 >> 0x28)]))
b1 = b0 ~mod+ DIFFS[0x07 & (c64 >> 0x28)]
if (b1 >> 5) <> 0 {
this.decode_planar_mode!(
bits: c64,
offset: 16 * bi)
bi += 1
continue
}
b0 = (b0 ~mod<< 3) | (b0 >> 2)
b1 = (b1 ~mod<< 3) | (b1 >> 2)
}
@@ -306,6 +344,264 @@ pri func decoder.from_src_to_buffer?(src: base.io_reader) {
this.buffer_index = bi
}
pri func decoder.decode_t_mode!(
bits: base.u64,
offset: base.u32[..= 1008]) {
var r : array[4] base.u8
var g : array[4] base.u8
var b : array[4] base.u8
var which : base.u32[..= 7]
var delta : base.u32
var y : base.u32
var x : base.u32
var x4y : base.u32[..= 15]
var i : base.u32[..= 3]
var o : base.u32[..= 4092]
// Unjumble T-mode's 59 bits and convert from RGB444 to RGB888.
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec
// 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex
// .. .. .. R0 r0 .. r0 r0 G0 g0 g0 g0 B0 b0 b0 b0 R2 r2 r2 r2 G2 g2 g2 g2 B2 b2 b2 b2 Wh wh .. wh
//
// The low 32 bits hold "2 bits per pixel" indexes into the r, g, b arrays.
r[0] = ((0x0C & (args.bits >> 0x39)) as base.u8) |
((0x03 & (args.bits >> 0x38)) as base.u8)
r[0] = (r[0] << 4) | r[0]
g[0] = (0x0F & (args.bits >> 0x34)) as base.u8
g[0] = (g[0] << 4) | g[0]
b[0] = (0x0F & (args.bits >> 0x30)) as base.u8
b[0] = (b[0] << 4) | b[0]
r[2] = (0x0F & (args.bits >> 0x2C)) as base.u8
r[2] = (r[2] << 4) | r[2]
g[2] = (0x0F & (args.bits >> 0x28)) as base.u8
g[2] = (g[2] << 4) | g[2]
b[2] = (0x0F & (args.bits >> 0x24)) as base.u8
b[2] = (b[2] << 4) | b[2]
// Modulate.
which = ((0x06 & (args.bits >> 0x21)) as base.u32) |
((0x01 & (args.bits >> 0x20)) as base.u32)
delta = T_H_MODIFIERS[which] as base.u32
r[1] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023]
g[1] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023]
b[1] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023]
r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023]
g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023]
b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023]
// Paint the 4×4 block.
while y < 4 {
x = 0
while x < 4,
inv y < 4,
{
x4y = (x * 4) | y
i = (((args.bits >> x4y) & 1) as base.u32) |
(((args.bits >> (x4y + 15)) & 2) as base.u32)
o = args.offset + (x * 4) + (y * 1024)
this.buffer[o + 0] = b[i]
this.buffer[o + 1] = g[i]
this.buffer[o + 2] = r[i]
x += 1
}
y += 1
}
}
pri func decoder.decode_h_mode!(
bits: base.u64,
offset: base.u32[..= 1008]) {
var r : array[4] base.u8
var g : array[4] base.u8
var b : array[4] base.u8
var rgb0 : base.u32
var rgb2 : base.u32
var which : base.u32[..= 7]
var delta : base.u32
var y : base.u32
var x : base.u32
var x4y : base.u32[..= 15]
var i : base.u32[..= 3]
var o : base.u32[..= 4092]
// Unjumble H-mode's 58 bits (one of the 'which' bits is implied by order)
// and convert from RGB444 to RGB888.
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec
// 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex
// .. R0 r0 r0 r0 G0 g0 g0 .. .. .. g0 B0 .. b0 b0 b0 R2 r2 r2 r2 G2 g2 g2 g2 B2 b2 b2 b2 Wh .. wh
//
// The low 32 bits hold "2 bits per pixel" indexes into the r, g, b arrays.
r[0] = (0x0F & (args.bits >> 0x3B)) as base.u8
r[0] = (r[0] << 4) | r[0]
g[0] = ((0x0E & (args.bits >> 0x37)) as base.u8) |
((0x01 & (args.bits >> 0x34)) as base.u8)
g[0] = (g[0] << 4) | g[0]
b[0] = ((0x08 & (args.bits >> 0x30)) as base.u8) |
((0x07 & (args.bits >> 0x2F)) as base.u8)
b[0] = (b[0] << 4) | b[0]
r[2] = (0x0F & (args.bits >> 0x2B)) as base.u8
r[2] = (r[2] << 4) | r[2]
g[2] = (0x0F & (args.bits >> 0x27)) as base.u8
g[2] = (g[2] << 4) | g[2]
b[2] = (0x0F & (args.bits >> 0x23)) as base.u8
b[2] = (b[2] << 4) | b[2]
// Modulate.
rgb0 = ((r[0] as base.u32) << 0x10) |
((g[0] as base.u32) << 0x08) |
((b[0] as base.u32) << 0x00)
rgb2 = ((r[2] as base.u32) << 0x10) |
((g[2] as base.u32) << 0x08) |
((b[2] as base.u32) << 0x00)
which = ((0x04 & (args.bits >> 0x20)) as base.u32) |
((0x02 & (args.bits >> 0x1F)) as base.u32)
if rgb0 >= rgb2 {
which |= 1
}
delta = T_H_MODIFIERS[which] as base.u32
r[1] = CLAMP[((r[0] as base.u32) ~mod- delta) & 1023]
g[1] = CLAMP[((g[0] as base.u32) ~mod- delta) & 1023]
b[1] = CLAMP[((b[0] as base.u32) ~mod- delta) & 1023]
r[0] = CLAMP[((r[0] as base.u32) ~mod+ delta) & 1023]
g[0] = CLAMP[((g[0] as base.u32) ~mod+ delta) & 1023]
b[0] = CLAMP[((b[0] as base.u32) ~mod+ delta) & 1023]
r[3] = CLAMP[((r[2] as base.u32) ~mod- delta) & 1023]
g[3] = CLAMP[((g[2] as base.u32) ~mod- delta) & 1023]
b[3] = CLAMP[((b[2] as base.u32) ~mod- delta) & 1023]
r[2] = CLAMP[((r[2] as base.u32) ~mod+ delta) & 1023]
g[2] = CLAMP[((g[2] as base.u32) ~mod+ delta) & 1023]
b[2] = CLAMP[((b[2] as base.u32) ~mod+ delta) & 1023]
// Paint the 4×4 block.
while y < 4 {
x = 0
while x < 4,
inv y < 4,
{
x4y = (x * 4) | y
i = (((args.bits >> x4y) & 1) as base.u32) |
(((args.bits >> (x4y + 15)) & 2) as base.u32)
o = args.offset + (x * 4) + (y * 1024)
this.buffer[o + 0] = b[i]
this.buffer[o + 1] = g[i]
this.buffer[o + 2] = r[i]
x += 1
}
y += 1
}
}
pri func decoder.decode_planar_mode!(
bits: base.u64,
offset: base.u32[..= 1008]) {
var ro : base.u32
var go : base.u32
var bo : base.u32
var rh : base.u32
var gh : base.u32
var bh : base.u32
var rv : base.u32
var gv : base.u32
var bv : base.u32
var y : base.u32
var x : base.u32
var o : base.u32[..= 4092]
var rp : base.u32
var gp : base.u32
var bp : base.u32
// Unjumble Planar-mode's 57 bits and convert from RGB676 to RGB888.
//
// 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 dec
// 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 hex
// .. Ro ro ro ro ro ro Go .. go go go go go go Bo .. .. .. bo bo .. bo bo bo Rh rh rh rh rh .. rh
//
// 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 dec
// 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 hex
// Gh gh gh gh gh gh gh Bh bh bh bh bh bh Rv rv rv rv rv rv Gv gv gv gv gv gv gv Bv bv bv bv bv bv
ro = (0x3F & (args.bits >> 0x39)) as base.u32
ro = (ro ~mod<< 2) | (ro >> 4)
go = ((0x40 & (args.bits >> 0x32)) as base.u32) |
((0x3F & (args.bits >> 0x31)) as base.u32)
go = (go ~mod<< 1) | (go >> 6)
bo = ((0x20 & (args.bits >> 0x2B)) as base.u32) |
((0x18 & (args.bits >> 0x28)) as base.u32) |
((0x07 & (args.bits >> 0x27)) as base.u32)
bo = (bo ~mod<< 2) | (bo >> 4)
rh = ((0x3E & (args.bits >> 0x21)) as base.u32) |
((0x01 & (args.bits >> 0x20)) as base.u32)
rh = (rh ~mod<< 2) | (rh >> 4)
gh = (0x7F & (args.bits >> 0x19)) as base.u32
gh = (gh ~mod<< 1) | (gh >> 6)
bh = (0x3F & (args.bits >> 0x13)) as base.u32
bh = (bh ~mod<< 2) | (bh >> 4)
rv = (0x3F & (args.bits >> 0x0D)) as base.u32
rv = (rv ~mod<< 2) | (rv >> 4)
gv = (0x7F & (args.bits >> 0x06)) as base.u32
gv = (gv ~mod<< 1) | (gv >> 6)
bv = (0x3F & (args.bits >> 0x00)) as base.u32
bv = (bv ~mod<< 2) | (bv >> 4)
// Convert h and v colors from absolute to relative.
rh ~mod-= ro
gh ~mod-= go
bh ~mod-= bo
rv ~mod-= ro
gv ~mod-= go
bv ~mod-= bo
// Prepare to linearly interpolate (which involves dividing by 4).
ro ~mod*= 4
go ~mod*= 4
bo ~mod*= 4
// Paint the 4×4 block.
while y < 4 {
x = 0
while x < 4,
inv y < 4,
{
o = args.offset + (x * 4) + (y * 1024)
bp = ((x ~mod* bh) ~mod+ (y ~mod* bv)) ~mod+ bo
this.buffer[o + 0] = CLAMP[((bp ~mod+ 2) / 4) & 1023]
gp = ((x ~mod* gh) ~mod+ (y ~mod* gv)) ~mod+ go
this.buffer[o + 1] = CLAMP[((gp ~mod+ 2) / 4) & 1023]
rp = ((x ~mod* rh) ~mod+ (y ~mod* rv)) ~mod+ ro
this.buffer[o + 2] = CLAMP[((rp ~mod+ 2) / 4) & 1023]
x += 1
}
y += 1
}
}
pri func decoder.decode_half_block!(
bits: base.u32,
offset: base.u32[..= 1008],
@@ -507,6 +803,8 @@ pri const MODIFIERS : roarray[8] roarray[4] base.u32 = [
[0x0000_002F, 0x0000_00B7, 0xFFFF_FFD1, 0xFFFF_FF49], // [-183, -47, 47, 183] re-ordered.
]
pri const T_H_MODIFIERS : roarray[8] base.u8 = [3, 6, 11, 16, 23, 32, 41, 64]
pri const CLAMP : roarray[1024] base.u8 = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,