mirror of
https://github.com/crskycode/GARbro.git
synced 2024-10-23 23:58:17 +08:00
363 lines
13 KiB
C#
363 lines
13 KiB
C#
//! \file ImageHG3.cs
|
|
//! \date Sat Jul 19 17:31:09 2014
|
|
//! \brief Frontwing HG3 image format implementation.
|
|
//
|
|
// Copyright (C) 2014 by morkt
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.ComponentModel.Composition;
|
|
using System.Windows.Media.Imaging;
|
|
using System.Windows.Media;
|
|
using GameRes.Compression;
|
|
using GameRes.Utility;
|
|
|
|
namespace GameRes.Formats.CatSystem
|
|
{
|
|
[Export(typeof(ImageFormat))]
|
|
public class Hg3Format : ImageFormat
|
|
{
|
|
public override string Tag { get { return "HG3"; } }
|
|
public override string Description { get { return "Frontwing proprietary image format"; } }
|
|
public override uint Signature { get { return 0x332d4748; } }
|
|
|
|
public override ImageMetaData ReadMetaData (Stream stream)
|
|
{
|
|
var header = new byte[0x4c];
|
|
if (0x4c != stream.Read (header, 0, header.Length))
|
|
return null;
|
|
if (LittleEndian.ToUInt32 (header, 0) != Signature)
|
|
return null;
|
|
if (LittleEndian.ToUInt32 (header, 4) != 0x0c)
|
|
return null;
|
|
if (!Binary.AsciiEqual (header, 0x14, "stdinfo\0"))
|
|
return null;
|
|
if (0x38 != LittleEndian.ToUInt32 (header, 0x1c))
|
|
return null;
|
|
if (0x20 != LittleEndian.ToUInt32 (header, 0x2c))
|
|
return null;
|
|
uint width = LittleEndian.ToUInt32 (header, 0x24); // @@L0
|
|
uint height = LittleEndian.ToUInt32 (header, 0x28);
|
|
int pos_x = LittleEndian.ToInt32 (header, 0x30);
|
|
int pos_y = LittleEndian.ToInt32 (header, 0x34);
|
|
pos_x -= LittleEndian.ToInt32 (header, 0x44);
|
|
pos_y -= LittleEndian.ToInt32 (header, 0x48);
|
|
|
|
return new ImageMetaData
|
|
{
|
|
Width = width,
|
|
Height = height,
|
|
OffsetX = pos_x,
|
|
OffsetY = pos_y,
|
|
BPP = 32,
|
|
};
|
|
}
|
|
|
|
public override ImageData Read (Stream stream, ImageMetaData info)
|
|
{
|
|
stream.Position = 0x40;
|
|
bool flipped = 0 == (stream.ReadByte() & 1) || info.OffsetY < 0;
|
|
stream.Position = 0x4c;
|
|
var header = new byte[0x28];
|
|
if (0x28 != stream.Read (header, 0, header.Length))
|
|
return null;
|
|
if (!Binary.AsciiEqual (header, "img0000\0"))
|
|
return null;
|
|
uint data_size = LittleEndian.ToUInt32 (header, 0x0c);
|
|
if (data_size < 0x18)
|
|
return null;
|
|
if (info.Height != LittleEndian.ToUInt32 (header, 0x14))
|
|
return null;
|
|
uint packed2_size = LittleEndian.ToUInt32 (header, 0x18);
|
|
uint unpacked2_size = LittleEndian.ToUInt32 (header, 0x1c);
|
|
uint packed1_size = LittleEndian.ToUInt32 (header, 0x20);
|
|
uint unpacked1_size = LittleEndian.ToUInt32 (header, 0x24);
|
|
if (packed2_size + packed1_size < packed2_size)
|
|
return null;
|
|
if (unpacked2_size + unpacked1_size < unpacked2_size)
|
|
return null;
|
|
|
|
long data_pos = stream.Position;
|
|
using (var unpacked2 = ZLibCompressor.DeCompress (stream))
|
|
{
|
|
stream.Position = data_pos + packed2_size;
|
|
using (var unpacked1 = ZLibCompressor.DeCompress (stream))
|
|
{
|
|
var decoder = new Decoder (unpacked1.GetBuffer(), unpacked1_size,
|
|
unpacked2.GetBuffer(), unpacked2_size,
|
|
info.Width, info.Height);
|
|
decoder.Unpack();
|
|
var pixels = decoder.Data;
|
|
int stride = (int)info.Width * 4;
|
|
var bitmap = BitmapSource.Create ((int)info.Width, (int)info.Height, 96, 96,
|
|
PixelFormats.Bgra32, null, pixels, stride);
|
|
if (flipped)
|
|
{
|
|
var flipped_bitmap = new TransformedBitmap();
|
|
flipped_bitmap.BeginInit();
|
|
flipped_bitmap.Source = bitmap;
|
|
flipped_bitmap.Transform = new ScaleTransform { ScaleY = -1 };
|
|
flipped_bitmap.EndInit();
|
|
bitmap = flipped_bitmap;
|
|
}
|
|
bitmap.Freeze();
|
|
return new ImageData (bitmap, info);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Write (Stream file, ImageData image)
|
|
{
|
|
throw new NotImplementedException ("Hg3Format.Write not implemented");
|
|
}
|
|
|
|
class Decoder
|
|
{
|
|
byte[] m_in1;
|
|
byte[] m_in2;
|
|
byte[] m_image;
|
|
uint m_in1_size;
|
|
uint m_in2_size;
|
|
uint m_dst_size;
|
|
uint m_width;
|
|
uint m_height;
|
|
|
|
public byte[] Data { get { return m_image; } }
|
|
|
|
public Decoder (byte[] in1, uint in1_size, byte[] in2, uint in2_size,
|
|
uint width, uint height)
|
|
{
|
|
m_in1 = in1;
|
|
m_in1_size = in1_size;
|
|
m_in2 = in2;
|
|
m_in2_size = in2_size;
|
|
m_width = width;
|
|
m_height = height;
|
|
m_dst_size = width*height*4;
|
|
m_image = new byte[(int)m_dst_size];
|
|
}
|
|
|
|
uint esi;
|
|
uint edi;
|
|
uint eax;
|
|
uint ebx;
|
|
uint ecx;
|
|
uint edx;
|
|
|
|
uint L0, L1, L2, L3, L4;
|
|
uint m_plane;
|
|
|
|
public void Unpack ()
|
|
{
|
|
m_plane = 0;
|
|
edi = 0;
|
|
esi = 0;
|
|
ebx = 0;
|
|
eax = m_in1_size;
|
|
L0 = m_in2_size;
|
|
L1 = 0;
|
|
bool skip_first = GetNextBit();
|
|
Proc4();
|
|
ecx = m_dst_size;
|
|
if (eax > m_dst_size)
|
|
throw new InvalidFormatException ("Underflow at Hg3Format.Decoder.Unpack()");
|
|
m_dst_size -= eax;
|
|
ecx >>= 2;
|
|
L2 = eax;
|
|
L3 = ecx;
|
|
L4 = ecx;
|
|
for (;;)
|
|
{
|
|
if (!skip_first)
|
|
{
|
|
// @@1:
|
|
if (0 == L2)
|
|
break;
|
|
Proc4();
|
|
ecx = eax;
|
|
if (ecx > L2)
|
|
throw new InvalidFormatException ("Overflow at Hg3Format.Decoder.Unpack()");
|
|
L2 -= ecx;
|
|
eax = 0;
|
|
do
|
|
Proc2();
|
|
while (0 != --ecx);
|
|
}
|
|
// @@1a:
|
|
if (0 == L2)
|
|
break;
|
|
Proc4();
|
|
ecx = eax;
|
|
if (ecx > L2 || ecx > L0)
|
|
throw new InvalidFormatException ("Overflow (2) at Hg3Format.Decoder.Unpack()");
|
|
L2 -= ecx;
|
|
L0 -= ecx;
|
|
do
|
|
{
|
|
eax = m_in2[L1++];
|
|
Proc2();
|
|
}
|
|
while (0 != --ecx);
|
|
skip_first = false;
|
|
}
|
|
// @@7:
|
|
ecx = m_dst_size;
|
|
esi = 0;
|
|
if (0 != ecx)
|
|
{
|
|
eax = 0;
|
|
do
|
|
Proc2();
|
|
while (0 != --ecx);
|
|
}
|
|
Proc6 (m_width, m_height);
|
|
// @@9:
|
|
eax = 0;
|
|
edx = m_in1_size;
|
|
}
|
|
|
|
void Proc2 () // @@2
|
|
{
|
|
m_image[edi] = (byte)eax;
|
|
edi += 4;
|
|
if (0 == --L3)
|
|
{
|
|
edi = ++m_plane;
|
|
L3 = L4;
|
|
}
|
|
}
|
|
|
|
bool GetNextBit () // @@3
|
|
{
|
|
bool carry = 0 != (ebx & 1);
|
|
ebx >>= 1;
|
|
if (0 == ebx)
|
|
{
|
|
if (0 == m_in1_size--)
|
|
throw new InvalidFormatException ("Hg3Format.Decoder.Underflow at GetNextBit()");
|
|
ebx = (uint)(m_in1[esi++] | 0x100);
|
|
carry = 0 != (ebx & 1);
|
|
ebx >>= 1;
|
|
}
|
|
return carry;
|
|
}
|
|
|
|
void Proc4 () // @@4
|
|
{
|
|
ecx = 0;
|
|
eax = 0;
|
|
do
|
|
{
|
|
if (ecx >= 0x20)
|
|
throw new InvalidFormatException ("Hg3Format.Decoder.Overflow at Proc4");
|
|
++ecx;
|
|
}
|
|
while (!GetNextBit());
|
|
++eax;
|
|
while (0 != --ecx)
|
|
{
|
|
eax += eax + (uint)(GetNextBit() ? 1 : 0);
|
|
}
|
|
}
|
|
|
|
void Proc6 (uint width, uint height)
|
|
{
|
|
uint[] table = new uint[0x100];
|
|
ecx = 0;
|
|
for (uint i = 0; i < 0x100; ++i)
|
|
{
|
|
eax = 0xffffffff;
|
|
edx = i;
|
|
do
|
|
{
|
|
eax >>= 2;
|
|
eax |= (edx & 3) << 30;
|
|
eax >>= 6;
|
|
edx >>= 2;
|
|
}
|
|
while (0 != (0x80 & eax));
|
|
table[i] = eax;
|
|
}
|
|
ecx = width * height * 4;
|
|
for (uint i = 0; i < ecx; i += 4)
|
|
{
|
|
eax = m_image[i];
|
|
edx = table[eax];
|
|
edx <<= 2;
|
|
eax = m_image[i+1];
|
|
edx += table[eax];
|
|
edx <<= 2;
|
|
eax = m_image[i+2];
|
|
edx += table[eax];
|
|
edx <<= 2;
|
|
eax = m_image[i+3];
|
|
edx += table[eax];
|
|
m_image[i] = (byte)(edx);
|
|
m_image[i+1] = (byte)(edx >> 8);
|
|
m_image[i+2] = (byte)(edx >> 16);
|
|
m_image[i+3] = (byte)(edx >> 24);
|
|
}
|
|
edi = 0;
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
eax = m_image[edi];
|
|
edx = (uint)(0 == (eax & 1) ? 0 : 0xff);
|
|
eax >>= 1;
|
|
eax ^= edx;
|
|
m_image[edi++] = (byte)eax;
|
|
}
|
|
ecx = width;
|
|
if (0 != --ecx)
|
|
{
|
|
ecx <<= 2;
|
|
do
|
|
{
|
|
eax = m_image[edi];
|
|
edx = (uint)(0 == (eax & 1) ? 0 : 0xff);
|
|
eax >>= 1;
|
|
eax ^= edx;
|
|
eax += m_image[edi-4];
|
|
m_image[edi++] = (byte)eax;
|
|
}
|
|
while (0 != --ecx);
|
|
}
|
|
ecx = height;
|
|
if (0 != --ecx)
|
|
{
|
|
uint stride = width*4;
|
|
ecx *= stride;
|
|
do
|
|
{
|
|
eax = m_image[edi];
|
|
edx = (uint)(0 == (eax & 1) ? 0 : 0xff);
|
|
eax >>= 1;
|
|
eax ^= edx;
|
|
eax += m_image[edi-stride];
|
|
m_image[edi++] = (byte)eax;
|
|
}
|
|
while (0 != --ecx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|