lifegpc/GARbro-crskycode
1
0
Fork 0
mirror of https://github.com/crskycode/GARbro.git synced 2026-06-06 05:38:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: Support multi-layer qoi

Browse Source
This commit is contained in:
Crsky
2026-03-17 09:41:29 +08:00
parent cd548330a9
commit bb2c831206
3 changed files with 333 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
ArcFormats/ArcFormats.csproj
View File

@@ -61,6 +61,9 @@
<Reference Include="ICSharpCode.SharpZipLib, Version=1.4.2.13, Culture=neutral, PublicKeyToken=1b03e6acf1164f73, processorArchitecture=MSIL">
<HintPath>..\packages\SharpZipLib.1.4.2\lib\netstandard2.0\ICSharpCode.SharpZipLib.dll</HintPath>
</Reference>
<Reference Include="K4os.Compression.LZ4, Version=1.3.8.0, Culture=neutral, PublicKeyToken=2186fa9121ef231d, processorArchitecture=MSIL">
<HintPath>..\packages\K4os.Compression.LZ4.1.3.8\lib\net462\K4os.Compression.LZ4.dll</HintPath>
</Reference>
<Reference Include="Microsoft.Bcl.HashCode, Version=6.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
<HintPath>..\packages\Microsoft.Bcl.HashCode.6.0.0\lib\net462\Microsoft.Bcl.HashCode.dll</HintPath>
</Reference>

330
ArcFormats/KiriKiri/ImageTLG.cs
View File

@@ -16,6 +16,8 @@ using GameRes.Utility;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using K4os.Compression.LZ4;
using System.Threading.Tasks;
namespace GameRes.Formats.KiriKiri
{
@@ -1178,21 +1180,347 @@ namespace GameRes.Formats.KiriKiri
return output;
}
class Lz4DecodeStream
{
readonly IBinaryStream m_input;
readonly byte[][] m_buffer;
readonly int[] m_size;
int m_index;
int m_pos;
const int BUFFER_SIZE = 0x8000;
public Lz4DecodeStream (IBinaryStream input)
{
m_input = input;
m_buffer = new byte[2][];
m_size = new int[2];
for (var i = 0; i < m_buffer.Length; i++)
m_buffer[i] = new byte[BUFFER_SIZE];
}
bool FillBuffer ()
{
if (m_input.Position == m_input.Length)
return false;
var v1 = m_input.ReadUInt16 ();
var v2 = m_input.ReadUInt16 ();
var input = m_input.ReadBytes (v2);
if (v2 != input.Length)
throw new EndOfStreamException ();
var size = v1 & 0x7FFF;
if (0 == size)
size = 0x8000;
var dst = m_index ^ 1;
var dic = m_index;
int num;
if (0 != (v1 & 0x8000))
{
if (0 == m_size[dic])
throw new InvalidFormatException ();
num = LZ4Codec.Decode (input, m_buffer[dst], m_buffer[dic].AsSpan (0, m_size[dic]));
}
else
num = LZ4Codec.Decode (input, m_buffer[dst]);
if (-1 == num || size != num)
throw new InvalidFormatException ();
m_size[dst] = num;
m_index ^= 1;
m_pos = 0;
return true;
}
public int ReadByte ()
{
if (m_pos == m_size[m_index])
{
if (!FillBuffer ())
return -1;
}
var idx = m_index;
if (m_pos == m_size[idx])
return -1;
return m_buffer[idx][m_pos++];
}
}
class RunDecodeStream
{
readonly Lz4DecodeStream m_input;
public RunDecodeStream (IBinaryStream input)
{
m_input = new Lz4DecodeStream (input);
}
public int Read ()
{
var value = 0;
var shift = 0;
while (shift < 32)
{
var b = m_input.ReadByte ();
if (-1 == b)
throw new EndOfStreamException ();
value |= (int)(b & 0x7F) << shift;
if (0 == (b & 0x80))
break;
shift += 7;
}
return value;
}
}
class QoiDecodeStream
{
readonly IBinaryStream m_input;
readonly byte[] m_table;
uint m_pixel;
public QoiDecodeStream (IBinaryStream input)
{
m_input = input;
m_table = new byte[4*QoiCodec.HashTableSize];
m_pixel = 0xFF000000;
}
public int Read (out uint output)
{
var r = (byte)m_pixel;
var g = (byte)(m_pixel >> 8);
var b = (byte)(m_pixel >> 16);
var a = (byte)(m_pixel >> 24);
var run = 1;
var b1 = m_input.ReadByte ();
if (-1 == b1)
throw new EndOfStreamException ();
if (QoiCodec.Rgb == b1)
{
var rgb = m_input.ReadInt24 ();
r = (byte)rgb;
g = (byte)(rgb >> 8);
b = (byte)(rgb >> 16);
}
else if (QoiCodec.Rgba == b1)
{
var rgba = m_input.ReadInt32 ();
r = (byte)rgba;
g = (byte)(rgba >> 8);
b = (byte)(rgba >> 16);
a = (byte)(rgba >> 24);
}
else if (QoiCodec.Index == (b1 & QoiCodec.Mask2))
{
var p1 = (b1 & ~QoiCodec.Mask2) * 4;
r = m_table[p1 ];
g = m_table[p1+1];
b = m_table[p1+2];
a = m_table[p1+3];
}
else if (QoiCodec.Diff == (b1 & QoiCodec.Mask2))
{
r += (byte)(((b1 >> 4) & 0x03) - 2);
g += (byte)(((b1 >> 2) & 0x03) - 2);
b += (byte)((b1 & 0x03) - 2);
}
else if (QoiCodec.Luma == (b1 & QoiCodec.Mask2))
{
var b2 = m_input.ReadByte ();
if (-1 == b2)
throw new EndOfStreamException ();
var vg = (b1 & 0x3F) - 32;
r += (byte)(vg - 8 + ((b2 >> 4) & 0x0F));
g += (byte)vg;
b += (byte)(vg - 8 + (b2 & 0x0F));
}
else if (QoiCodec.Run == (b1 & QoiCodec.Mask2))
{
run = (b1 & 0x3F) + 1;
}
var p2 = (r*3 + g*5 + b*7 + a*11) % QoiCodec.HashTableSize*4;
m_table[p2 ] = r;
m_table[p2+1] = g;
m_table[p2+2] = b;
m_table[p2+3] = a;
m_pixel = (uint)(r | (g << 8) | (b << 16) | (a << 24));
output = (uint)(b | (g << 8) | (r << 16) | (a << 24));
return run;
}
}
class QoiBlockDecoder
{
readonly QoiDecodeStream m_qoi;
readonly RunDecodeStream m_run;
readonly int m_pixel_count;
readonly int m_layer_index;
readonly int m_layer_count;
readonly byte[] m_output;
readonly int m_dst;
public QoiBlockDecoder (byte[] qoi, byte[] run, int pixel_count, int layer_index, int layer_count, byte[] output, int dst)
{
m_qoi = new QoiDecodeStream (new BinMemoryStream (qoi));
m_run = new RunDecodeStream (new BinMemoryStream (run));
m_pixel_count = pixel_count;
m_layer_index = layer_index;
m_layer_count = layer_count;
m_output = output;
m_dst = dst;
}
public void Decode ()
{
m_qoi.Read (out var p0);
m_qoi.Read (out var p1);
if (0 != p0 || 0xFF000000 != p1)
throw new InvalidFormatException ();
var r0 = m_run.Read();
if (0 != r0)
throw new InvalidFormatException ();
var dst = m_dst;
var count = m_pixel_count;
var skip = m_layer_index;
while (count --> 0)
{
var r1 = m_qoi.Read (out var pixel);
var r2 = m_run.Read ();
var run = r1 + r2;
while (run --> 0)
{
if (skip > 0)
--skip;
else
{
skip = m_layer_count-1;
m_output[dst ] = (byte)pixel;
m_output[dst+1] = (byte)(pixel >> 8);
m_output[dst+2] = (byte)(pixel >> 16);
m_output[dst+3] = (byte)(pixel >> 24);
dst += 4;
}
}
}
}
}
long[] DecodeArray (ReadOnlySpan<byte> input)
{
var output = new List<long> (input.Length);
var i = 0;
while (i < input.Length)
{
long value = 0;
var shift = 0;
while (shift < 64)
{
var b = input[i++];
value |= (long)(b & 0x7F) << shift;
if (0 == (b & 0x80))
break;
shift += 7;
if (i >= input.Length)
throw new EndOfStreamException ();
}
output.Add (value);
}
return output.ToArray ();
}
long[] ReadArray (IBinaryStream src, long offset, int signature)
{
src.Position = offset;
if (signature != src.ReadInt32 ())
throw new InvalidFormatException ();
var length = src.ReadInt32 ();
var input = src.ReadBytes (length);
if (input.Length != length)
throw new EndOfStreamException ();
return DecodeArray (input);
}
byte[] DecodeMultiLayerQOI (IBinaryStream src, uint width, uint height, byte[] qhdr, int layer)
{
var data_offset = src.Position;
var layer_count = qhdr.ToInt32 (4);
var block_height = qhdr.ToInt32 (8);
var block_count = qhdr.ToInt32 (12);
var dtbl_offset = qhdr.ToInt64 (24);
var rtbl_offset = qhdr.ToInt64 (32);
if (layer_count < 1)
throw new InvalidFormatException ();
if (0 == block_count)
throw new NotImplementedException ();
long[] dtbl = ReadArray (src, data_offset+dtbl_offset, 0x4C425444);
if (0 == dtbl.Length || dtbl.Length != 1+2*block_count || dtbl[0] != dtbl.Length-1)
throw new InvalidFormatException ();
long[] rtbl = ReadArray (src, data_offset+rtbl_offset, 0x4C425452);
if (0 == rtbl.Length || rtbl.Length != 1+block_count || rtbl[0] != rtbl.Length-1)
throw new InvalidFormatException ();
var tasks = new List<Task> (block_count);
var output = new byte[4*width*height];
var qoi_offset = data_offset;
var run_offset = src.Position;
for (var i = 0; i < block_count; i++)
{
var qoi_size = (int) dtbl[1+2*i];
var run_size = (int) rtbl[1+i];
var num_pixels = (int) dtbl[1+2*i+1];
src.Position = qoi_offset;
var qoi = src.ReadBytes (qoi_size);
if (qoi_size != qoi.Length)
throw new EndOfStreamException ();
src.Position = run_offset;
var run = src.ReadBytes (run_size);
if (run_size != run.Length)
throw new EndOfStreamException ();
qoi_offset += qoi_size;
run_offset += run_size;
var dst = block_height*i * 4*(int)width;
var decoder = new QoiBlockDecoder (qoi, run, num_pixels, layer, layer_count, output, dst);
var task = Task.Run (() => decoder.Decode ());
tasks.Add (task);
}
Task.WhenAll (tasks).Wait ();
return output;
}
byte[] ReadQOI (IBinaryStream src, TlgMetaData info)
{
var qhdr = Array.Empty<byte> ();
while (true)
{
var entry_signature = src.ReadInt32 ();
var entry_size = src.ReadInt32 ();
if (0x52444851 == entry_signature) // 'QHDR'
{
throw new NotImplementedException ();
if (0x30 != entry_size)
throw new InvalidFormatException ();
qhdr = src.ReadBytes (entry_size);
if (qhdr.Length != entry_size)
throw new EndOfStreamException ();
}
else if (0 == entry_signature && 0 == entry_size)
break;
else
throw new InvalidFormatException ();
}
if (0 != qhdr.Length)
return DecodeMultiLayerQOI (src, info.Width, info.Height, qhdr, 0);
return DecodeQOI (src, info.Width, info.Height);
}

1
ArcFormats/packages.config
View File

@@ -2,6 +2,7 @@
<packages>
<package id="BCnEncoder.Net" version="2.3.0" targetFramework="net472" />
<package id="CommunityToolkit.HighPerformance" version="8.4.0" targetFramework="net472" />
<package id="K4os.Compression.LZ4" version="1.3.8" targetFramework="net472" />
<package id="Microsoft.Bcl.HashCode" version="6.0.0" targetFramework="net472" />
<package id="Microsoft.Bcl.Numerics" version="10.0.3" targetFramework="net472" />
<package id="Microsoft.Win32.Registry" version="5.0.0" targetFramework="net472" />