lifegpc/GARbro-crskycode
1
0
Fork 0
mirror of https://github.com/crskycode/GARbro.git synced 2026-07-08 01:30:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

(PX): additional formats.

Browse Source
This commit is contained in:
morkt
2017-03-24 22:45:43 +04:00
parent 0d98917d5e
commit 5620f48ea9
2 changed files with 330 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

291
ArcFormats/Leaf/ImagePX.cs
View File

@@ -27,6 +27,7 @@ using System;
using System.ComponentModel.Composition;
using System.IO;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using GameRes.Utility;
namespace GameRes.Formats.Leaf
@@ -78,7 +79,7 @@ namespace GameRes.Formats.Leaf
BlocksHeight = header.ToUInt16 (0x1E),
};
}
else if (0x80 == type || 0x90 == type)
else if (0x90 == type)
{
if (!header.AsciiEqual (0x14, "Leaf"))
return null;
@@ -99,6 +100,34 @@ namespace GameRes.Formats.Leaf
FrameCount = count,
};
}
else if (0x40 == type || 0x44 == type)
{
int count = header.ToInt32 (0);
if (!ArchiveFormat.IsSaneCount (count))
return null;
return new PxMetaData
{
Width = header.ToUInt32 (0x14),
Height = header.ToUInt32 (0x18),
Type = 0x40,
BPP = 32,
FrameCount = count,
};
}
else if (1 == type || 4 == type || 7 == type)
{
int bpp = header.ToUInt16 (0x12);
if (bpp != 32 && bpp != 8)
return null;
return new PxMetaData
{
Width = header.ToUInt32 (0x14),
Height = header.ToUInt32 (0x18),
Type = type,
BPP = bpp,
FrameCount = 1,
};
}
return null;
}
@@ -107,7 +136,7 @@ namespace GameRes.Formats.Leaf
using (var reader = new PxReader (stream, (PxMetaData)info))
{
var pixels = reader.Unpack();
return ImageData.Create (info, reader.Format, null, pixels, reader.Stride);
return ImageData.Create (info, reader.Format, reader.Palette, pixels, reader.Stride);
}
}
@@ -125,10 +154,11 @@ namespace GameRes.Formats.Leaf
int m_pixel_size;
int m_stride;
public PixelFormat Format { get { return PixelFormats.Bgra32; } }
public PixelFormat Format { get; private set; }
public byte[] Data { get { return m_output; } }
public int Stride { get { return m_stride; } }
public int FrameCount { get { return m_info.FrameCount; } }
public BitmapPalette Palette { get; private set; }
public PxReader (IBinaryStream input, PxMetaData info)
{
@@ -137,6 +167,10 @@ namespace GameRes.Formats.Leaf
m_pixel_size = m_info.BPP / 8;
m_stride = (int)m_info.Width * m_pixel_size;
m_output = new byte[m_stride * (int)m_info.Height];
if (1 == m_pixel_size)
Format = PixelFormats.Gray8;
else
Format = PixelFormats.Bgra32;
}
public byte[] Unpack (int frame = 0)
@@ -147,8 +181,8 @@ namespace GameRes.Formats.Leaf
{
case 0x0C: Unpack0C (frame); break;
case 0x90: Unpack90 (frame); break;
case 0x80: Unpack80 (frame); break;
default: throw new NotImplementedException();
case 0x40: Unpack40(); break;
default: ReadBlock (0); break;
}
return m_output;
}
@@ -195,11 +229,256 @@ namespace GameRes.Formats.Leaf
throw new EndOfStreamException();
}
void Unpack80 (int frame)
void Unpack40 ()
{
m_input.Position = 0x20;
uint data_offset = 0x20 + (uint)m_info.FrameCount * 4;
var offsets = new uint[m_info.FrameCount];
for (int i = 0; i < offsets.Length; ++i)
offsets[i] = data_offset + m_input.ReadUInt32();
foreach (var offset in offsets)
ReadBlock (offset);
}
internal class PxBlock
{
public int Width;
public int Height;
public int X;
public int Y;
public int Type;
public int Bits;
}
void ReadBlock (uint offset)
{
m_input.Position = offset;
var px = new PxBlock();
px.Width = m_input.ReadInt32();
px.Height = m_input.ReadInt32();
px.X = m_input.ReadInt32();
px.Y = m_input.ReadInt32();
px.Type = m_input.ReadUInt16();
px.Bits = m_input.ReadUInt16();
m_input.Position = offset + 0x20;
switch (px.Type)
{
case 0:
Palette = ImageFormat.ReadPalette (m_input.AsStream, (int)px.Width);
break;
case 1:
switch (px.Bits)
{
case 8: UnpackBlock_1_8 (px); break;
case 0x20: UnpackBlock_1_20 (px); break;
}
break;
case 4:
switch (px.Bits)
{
case 8: UnpackBlock_4_8 (px); break;
case 9: UnpackBlock_4_9 (px); break;
case 0x20: UnpackBlock_4_20 (px); break;
case 0x30: UnpackBlock_4_30 (px); break;
}
break;
case 7:
UnpackBlock_7 (px);
break;
default:
throw new InvalidFormatException();
}
}
void UnpackBlock_1_8 (PxBlock block)
{
m_input.Read (m_output, 0, (int)m_info.Width * (int)m_info.Height);
}
void UnpackBlock_1_20 (PxBlock block)
{
int dst = 0;
for (int y = 0; y < block.Height; ++y)
for (int x = 0; x < block.Width; ++x)
{
m_input.Read (m_output, dst, 4);
if (0 != m_output[dst+3])
{
byte alpha = (byte)((m_output[dst+3] << 1 | m_output[dst+2] >> 7) + 0xFF);
m_output[dst+3] = alpha;
}
else
{
m_output[dst+3] = 0xFF;
}
dst += 4;
}
}
void UnpackBlock_4_8 (PxBlock block)
{
throw new NotImplementedException();
}
const int MaxBlockSize = 1024;
// lazily evaluated to avoid unnecessary allocation
Lazy<uint[]> m_block = new Lazy<uint[]> (() => new uint[MaxBlockSize * MaxBlockSize]);
uint[] NewBlock (PxBlock block_info)
{
var block = m_block.Value;
Array.Clear (block, 0, MaxBlockSize * block_info.Height);
return block;
}
void UnpackBlock_4_9 (PxBlock block_info)
{
var output = NewBlock (block_info);
int dst = 0;
bool has_alpha = true;
for (;;)
{
int code = m_input.ReadInt32();
if (-1 == code)
break;
if (0 != (code & 0x180000))
has_alpha = !has_alpha;
dst += (code & 0x1FF) * MaxBlockSize;
dst += code >> 21;
int count = (code >> 9) & 0x3FF;
for (int i = 0; i < count; ++i)
{
byte alpha = (byte)(has_alpha ? (m_input.ReadUInt8() << 1) - 1 : 0xFF);
int color_idx = m_input.ReadByte();
if (dst < output.Length)
{
var color = Palette.Colors[color_idx];
output[dst] = (uint)(color.B | color.G << 8 | color.R << 16 | alpha << 24);
}
dst++;
}
}
PutBlock (block_info);
}
void UnpackBlock_4_20 (PxBlock block_info)
{
var block = NewBlock (block_info);
int dst = 0;
int next;
while ((next = m_input.ReadInt32()) != -1)
{
if (next < 0 || next > 0xFFFFFF)
continue;
dst += next / 4;
m_input.ReadInt32();
int count = m_input.ReadInt32();
while (count --> 0)
{
uint color = m_input.ReadUInt32();
if (dst < block.Length)
{
if (0 != (color & 0xFF000000))
{
uint alpha = ((color >> 23) + 0xFF) << 24;
block[dst] = (color & 0xFFFFFFu) | alpha;
}
else
{
block[dst] = color | 0xFF000000u;
}
}
++dst;
}
}
PutBlock (block_info);
}
void UnpackBlock_4_30 (PxBlock block_info)
{
var output = NewBlock (block_info);
int dst = 0;
for (;;)
{
int next = m_input.ReadInt32();
if (-1 == next)
break;
if (0 != (next & 0xFF000000))
continue;
dst += next / 4;
m_input.ReadInt32();
int count = m_input.ReadInt32();
for (int i = 0; i < count; ++i)
{
uint color = m_input.ReadUInt32();
m_input.ReadInt16();
if (dst < output.Length)
{
if (0 != (color & 0xFF000000))
{
uint alpha = ((color >> 23) + 0xFF) << 24;
output[dst] = (color & 0xFFFFFF) | alpha;
}
else
{
output[dst] = 0;
}
}
dst++;
}
}
PutBlock (block_info);
}
void UnpackBlock_7 (PxBlock block)
{
m_stride = 4 * block.Width;
m_output = new byte[m_stride * block.Height];
Format = PixelFormats.Bgra32;
m_info.OffsetX = block.X;
m_info.OffsetY = block.Y;
int dst = 0;
var color_map = ImageFormat.ReadColorMap (m_input.AsStream, 0x100, PaletteFormat.BgrA);
for (int y = 0; y < block.Height; ++y)
for (int x = 0; x < block.Width; ++x)
{
int idx = m_input.ReadUInt8();
var c = color_map[idx];
m_output[dst++] = c.B;
m_output[dst++] = c.G;
m_output[dst++] = c.R;
if (c.A != 0)
m_output[dst++] = (byte)((c.A << 1 | c.R >> 7) + 0xFF);
else
m_output[dst++] = 0xFF;
}
}
void PutBlock (PxBlock block_info)
{
var block = m_block.Value;
int left = Math.Max (0, block_info.X);
int top = Math.Max (0, block_info.Y);
int right = Math.Min (block_info.X + block_info.Width, (int)m_info.Width);
int bottom = Math.Min (block_info.Y + block_info.Height, (int)m_info.Height);
int dst_row = top * m_stride + left * 4;
int row_size = (right - left) * 4;
for (int y = top; y < bottom; ++y)
{
int src = (left - block_info.X) + (y - block_info.Y) * MaxBlockSize;
Buffer.BlockCopy (block, src * 4, m_output, dst_row, row_size);
dst_row += m_stride;
}
}
#region IDisposable Members
public void Dispose ()
{