Public-Mirror/GARbro-mirror
1
0
Fork 0
mirror of https://github.com/crskycode/GARbro.git synced 2024-11-23 21:55:34 +08:00
Code Issues Projects Releases Wiki Activity

overhauled HG3 reader.

Browse Source
This commit is contained in:
morkt 2015-11-29 12:27:49 +04:00
parent da51f3d7b2
commit bc0af8d910
2 changed files with 118 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ArcFormats/CatSystem/ArcHG3.cs
View File

@ -23,13 +23,10 @@
// IN THE SOFTWARE.
//
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.IO;
using System.Windows;
using GameRes.Utility;
using GameRes.Compression;
namespace GameRes.Formats.CatSystem
{
@ -77,7 +74,7 @@ namespace GameRes.Formats.CatSystem
{
// emulate TGA image
var offset = entry.Offset+8;
var info = new Hg3MetaData
var info = new HgMetaData
{
HeaderSize = arc.File.View.ReadUInt32 (offset),
Width = arc.File.View.ReadUInt32 (offset+8),

214
ArcFormats/CatSystem/ImageHG3.cs
View File

@ -34,7 +34,7 @@ using GameRes.Utility;
namespace GameRes.Formats.CatSystem
{
internal class Hg3MetaData : ImageMetaData
internal class HgMetaData : ImageMetaData
{
public uint CanvasWidth;
public uint CanvasHeight;
@ -57,7 +57,7 @@ namespace GameRes.Formats.CatSystem
return null;
if (!Binary.AsciiEqual (header, 0x14, "stdinfo\0"))
return null;
return new Hg3MetaData
return new HgMetaData
{
HeaderSize = LittleEndian.ToUInt32 (header, 0x1C),
Width = LittleEndian.ToUInt32 (header, 0x24),
@ -72,9 +72,7 @@ namespace GameRes.Formats.CatSystem
public override ImageData Read (Stream stream, ImageMetaData info)
{
var meta = info as Hg3MetaData;
if (null == meta)
throw new ArgumentException ("Hg3Format.Read should be supplied with Hg3MetaData", "info");
var meta = (HgMetaData)info;
if (0x20 != meta.BPP)
throw new NotSupportedException ("Not supported HG-3 color depth");
@ -82,11 +80,10 @@ namespace GameRes.Formats.CatSystem
using (var reader = new Hg3Reader (input, meta))
{
var pixels = reader.Unpack();
int stride = (int)info.Width * info.BPP / 8;
if (reader.Flipped)
return ImageData.CreateFlipped (info, PixelFormats.Bgra32, null, pixels, stride);
return ImageData.CreateFlipped (info, PixelFormats.Bgra32, null, pixels, reader.Stride);
else
return ImageData.Create (info, PixelFormats.Bgra32, null, pixels, stride);
return ImageData.Create (info, PixelFormats.Bgra32, null, pixels, reader.Stride);
}
}
@ -96,51 +93,34 @@ namespace GameRes.Formats.CatSystem
}
}
internal sealed class Hg3Reader : IDisposable
internal class HgReader : IDisposable
{
BinaryReader m_input;
Hg3MetaData m_info;
int m_pixel_size;
private BinaryReader m_input;
protected HgMetaData m_info;
protected int m_pixel_size;
public bool Flipped { get; private set; }
protected BinaryReader Input { get { return m_input; } }
protected Stream InputStream { get { return m_input.BaseStream; } }
public int Stride { get; protected set; }
public Hg3Reader (Stream input, Hg3MetaData info)
protected HgReader (Stream input, HgMetaData info)
{
m_input = new ArcView.Reader (input);
m_info = info;
m_pixel_size = m_info.BPP / 8;
Stride = (int)m_info.Width * m_pixel_size;
}
public byte[] Unpack ()
public byte[] UnpackStream (long data_offset, int data_packed, int data_unpacked, int ctl_packed, int ctl_unpacked)
{
m_input.BaseStream.Position = m_info.HeaderSize;
var img_type = m_input.ReadChars (8);
if (img_type.SequenceEqual ("img0000\0"))
return UnpackImg0000();
else if (img_type.SequenceEqual ("img_jpg\0"))
return UnpackJpeg();
else
throw new NotSupportedException ("Not supported HG-3 image");
}
byte[] UnpackImg0000 ()
{
Flipped = true;
m_input.BaseStream.Position = m_info.HeaderSize+0x18;
uint packed_data_size = m_input.ReadUInt32();
int data_size = m_input.ReadInt32();
uint packed_ctl_size = m_input.ReadUInt32();
int ctl_size = m_input.ReadInt32();
uint data_offset = m_info.HeaderSize + 0x28;
uint ctl_offset = data_offset + packed_data_size;
var data = new byte[data_size];
using (var z = new StreamRegion (m_input.BaseStream, data_offset, packed_data_size, true))
var ctl_offset = data_offset + data_packed;
var data = new byte[data_unpacked];
using (var z = new StreamRegion (InputStream, data_offset, data_packed, true))
using (var data_in = new ZLibStream (z, CompressionMode.Decompress))
if (data_size != data_in.Read (data, 0, data.Length))
if (data.Length != data_in.Read (data, 0, data.Length))
throw new EndOfStreamException();
using (var z = new StreamRegion (m_input.BaseStream, ctl_offset, packed_ctl_size, true))
using (var z = new StreamRegion (InputStream, ctl_offset, ctl_packed, true))
using (var ctl_in = new ZLibStream (z, CompressionMode.Decompress))
using (var bits = new LsbBitStream (ctl_in))
{
@ -164,54 +144,6 @@ namespace GameRes.Formats.CatSystem
}
}
byte[] UnpackJpeg ()
{
Flipped = false;
m_input.ReadInt32();
var jpeg_size = m_input.ReadInt32();
long next_section = m_input.BaseStream.Position + jpeg_size;
var decoder = new JpegBitmapDecoder (m_input.BaseStream,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
var frame = decoder.Frames[0];
if (frame.Format.BitsPerPixel < 24)
throw new NotSupportedException ("Not supported HG-3 JPEG color depth");
int src_pixel_size = frame.Format.BitsPerPixel/8;
int stride = (int)m_info.Width * src_pixel_size;
var pixels = new byte[stride*(int)m_info.Height];
frame.CopyPixels (pixels, stride, 0);
var output = new byte[m_info.Width*m_info.Height*4];
uint total = m_info.Width * m_info.Height;
int src = 0;
int dst = 0;
for (uint i = 0; i < total; ++i)
{
output[dst++] = pixels[src];
output[dst++] = pixels[src+1];
output[dst++] = pixels[src+2];
output[dst++] = 0xFF;
src += src_pixel_size;
}
m_input.BaseStream.Position = next_section;
var section_header = m_input.ReadChars (8);
if (!section_header.SequenceEqual ("img_al\0\0"))
return output;
m_input.BaseStream.Seek (8, SeekOrigin.Current);
int alpha_size = m_input.ReadInt32();
using (var alpha_in = new StreamRegion (m_input.BaseStream, m_input.BaseStream.Position+4, alpha_size, true))
using (var alpha = new ZLibStream (alpha_in, CompressionMode.Decompress))
{
for (int i = 3; i < output.Length; i += 4)
{
int b = alpha.ReadByte();
if (-1 == b)
throw new EndOfStreamException();
output[i] = (byte)b;
}
return output;
}
}
static int GetBitCount (LsbBitStream bits)
{
int n = 0;
@ -219,7 +151,7 @@ namespace GameRes.Formats.CatSystem
{
++n;
if (n >= 0x20)
throw new InvalidFormatException ("Overflow at Hg3Reader.GetBitCount");
throw new InvalidFormatException ("Overflow at HgReader.GetBitCount");
}
int value = 1;
while (n --> 0)
@ -270,22 +202,20 @@ namespace GameRes.Formats.CatSystem
output[dst++] = ConvertValue ((byte)(val >> 24));
}
int stride = (int)m_info.Width * m_pixel_size;
for (int x = m_pixel_size; x < stride; x++)
for (int x = m_pixel_size; x < Stride; x++)
{
output[x] += output[x - m_pixel_size];
}
int line = stride;
int line = Stride;
for (uint y = 1; y < m_info.Height; y++)
{
int prev = line - stride;
for (int x = 0; x < stride; x++)
int prev = line - Stride;
for (int x = 0; x < Stride; x++)
{
output[line+x] += output[prev+x];
}
line += stride;
line += Stride;
}
return output;
}
@ -299,14 +229,104 @@ namespace GameRes.Formats.CatSystem
#region IDisposable Members
bool _disposed = false;
public void Dispose ()
{
Dispose (true);
GC.SuppressFinalize (this);
}
protected virtual void Dispose (bool disposing)
{
if (!_disposed)
{
m_input.Dispose();
if (disposing)
{
m_input.Dispose();
}
_disposed = true;
}
}
#endregion
}
internal sealed class Hg3Reader : HgReader
{
public bool Flipped { get; private set; }
public Hg3Reader (Stream input, HgMetaData info) : base (input, info)
{
}
public byte[] Unpack ()
{
InputStream.Position = m_info.HeaderSize;
var img_type = Input.ReadChars (8);
if (img_type.SequenceEqual ("img0000\0"))
return UnpackImg0000();
else if (img_type.SequenceEqual ("img_jpg\0"))
return UnpackJpeg();
else
throw new NotSupportedException ("Not supported HG-3 image");
}
byte[] UnpackImg0000 ()
{
Flipped = true;
InputStream.Position = m_info.HeaderSize+0x18;
int packed_data_size = Input.ReadInt32();
int data_size = Input.ReadInt32();
int packed_ctl_size = Input.ReadInt32();
int ctl_size = Input.ReadInt32();
return UnpackStream (m_info.HeaderSize+0x28, packed_data_size, data_size, packed_ctl_size, ctl_size);
}
byte[] UnpackJpeg ()
{
Flipped = false;
Input.ReadInt32();
var jpeg_size = Input.ReadInt32();
long next_section = InputStream.Position + jpeg_size;
var decoder = new JpegBitmapDecoder (InputStream,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
var frame = decoder.Frames[0];
if (frame.Format.BitsPerPixel < 24)
throw new NotSupportedException ("Not supported HG-3 JPEG color depth");
int src_pixel_size = frame.Format.BitsPerPixel/8;
int stride = (int)m_info.Width * src_pixel_size;
var pixels = new byte[stride*(int)m_info.Height];
frame.CopyPixels (pixels, stride, 0);
var output = new byte[m_info.Width*m_info.Height*4];
uint total = m_info.Width * m_info.Height;
int src = 0;
int dst = 0;
for (uint i = 0; i < total; ++i)
{
output[dst++] = pixels[src];
output[dst++] = pixels[src+1];
output[dst++] = pixels[src+2];
output[dst++] = 0xFF;
src += src_pixel_size;
}
InputStream.Position = next_section;
var section_header = Input.ReadChars (8);
if (!section_header.SequenceEqual ("img_al\0\0"))
return output;
InputStream.Seek (8, SeekOrigin.Current);
int alpha_size = Input.ReadInt32();
using (var alpha_in = new StreamRegion (InputStream, InputStream.Position+4, alpha_size, true))
using (var alpha = new ZLibStream (alpha_in, CompressionMode.Decompress))
{
for (int i = 3; i < output.Length; i += 4)
{
int b = alpha.ReadByte();
if (-1 == b)
throw new EndOfStreamException();
output[i] = (byte)b;
}
return output;
}
}
}
}