mirror of
https://github.com/crskycode/GARbro.git
synced 2026-07-08 01:30:18 +08:00
(Legacy): added formats, mostly PC-98.
This commit is contained in:
morkt
141
Legacy/System98/ArcLIB.cs
Normal file
141
Legacy/System98/ArcLIB.cs
Normal file
@@ -0,0 +1,141 @@
|
||||
//! \file ArcLIB.cs
|
||||
//! \date 2023 Oct 15
|
||||
//! \brief System-98 resource archive (PC-98).
|
||||
//
|
||||
// Copyright (C) 2023 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 GameRes.Utility;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel.Composition;
|
||||
using System.IO;
|
||||
|
||||
namespace GameRes.Formats.System98
|
||||
{
|
||||
[Export(typeof(ArchiveFormat))]
|
||||
public class LibOpener : ArchiveFormat
|
||||
{
|
||||
public override string Tag => "LIB/SYSTEM98";
|
||||
public override string Description => "System-98 engine resource archive";
|
||||
public override uint Signature => 0x3062694C; // 'Lib0'
|
||||
public override bool IsHierarchic => false;
|
||||
public override bool CanWrite => false;
|
||||
|
||||
public override ArcFile TryOpen (ArcView file)
|
||||
{
|
||||
var cat_name = Path.ChangeExtension (file.Name, ".CAT");
|
||||
if (!VFS.FileExists (cat_name))
|
||||
return null;
|
||||
int count;
|
||||
byte[] index;
|
||||
using (var cat = VFS.OpenView (cat_name))
|
||||
{
|
||||
count = cat.View.ReadInt16 (4);
|
||||
if (!IsSaneCount (count))
|
||||
return null;
|
||||
int index_size = count * 0x16;
|
||||
if (cat.View.AsciiEqual (0, "Cat0"))
|
||||
{
|
||||
index = file.View.ReadBytes (6, (uint)index_size);
|
||||
}
|
||||
else if (cat.View.AsciiEqual (0, "Cat1"))
|
||||
{
|
||||
index = new byte[index_size];
|
||||
using (var input = cat.CreateStream (6))
|
||||
LzssUnpack (input, index);
|
||||
}
|
||||
else
|
||||
return null;
|
||||
}
|
||||
int pos = 0;
|
||||
var dir = new List<Entry> (count);
|
||||
for (int i = 0; i < count; ++i)
|
||||
{
|
||||
var name = Binary.GetCString (index, pos, 0xC).TrimEnd();
|
||||
var entry = Create<PackedEntry> (name);
|
||||
entry.Size = index.ToUInt32 (pos+0xE);
|
||||
entry.Offset = index.ToUInt32 (pos+0x12);
|
||||
if (!entry.CheckPlacement (file.MaxOffset))
|
||||
return null;
|
||||
entry.IsPacked = index[pos+0xC] != 0;
|
||||
dir.Add (entry);
|
||||
pos += 0x16;
|
||||
}
|
||||
return new ArcFile (file, this, dir);
|
||||
}
|
||||
|
||||
public override Stream OpenEntry (ArcFile arc, Entry entry)
|
||||
{
|
||||
var pent = entry as PackedEntry;
|
||||
if (null == pent || !pent.IsPacked)
|
||||
return base.OpenEntry (arc, entry);
|
||||
if (pent.UnpackedSize == 0)
|
||||
pent.UnpackedSize = arc.File.View.ReadUInt32 (entry.Offset+6);
|
||||
var data = new byte[pent.UnpackedSize];
|
||||
using (var input = arc.File.CreateStream (entry.Offset+10, entry.Size-10))
|
||||
{
|
||||
int length = LzssUnpack (input, data);
|
||||
return new BinMemoryStream (data, 0, length, entry.Name);
|
||||
}
|
||||
}
|
||||
|
||||
internal static int LzssUnpack (IBinaryStream input, byte[] output)
|
||||
{
|
||||
var frame = new byte[0x1000];
|
||||
int frame_pos = 1;
|
||||
int ctl = 0;
|
||||
byte mask = 0;
|
||||
int dst = 0;
|
||||
while (dst < output.Length)
|
||||
{
|
||||
mask <<= 1;
|
||||
if (0 == mask)
|
||||
{
|
||||
ctl = input.ReadByte();
|
||||
if (-1 == ctl)
|
||||
break;
|
||||
mask = 1;
|
||||
}
|
||||
if (input.PeekByte() == -1)
|
||||
break;
|
||||
if ((ctl & mask) != 0)
|
||||
{
|
||||
output[dst++] = frame[frame_pos++ & 0xFFF] = input.ReadUInt8();
|
||||
}
|
||||
else
|
||||
{
|
||||
int lo = input.ReadByte();
|
||||
int hi = input.ReadByte();
|
||||
if (-1 == hi)
|
||||
break;
|
||||
int count = (lo & 0xF) + 3;
|
||||
int off = hi << 4 | lo >> 4;
|
||||
while (count --> 0)
|
||||
{
|
||||
byte b = frame[off++ & 0xFFF];
|
||||
output[dst++] = frame[frame_pos++ & 0xFFF] = b;
|
||||
}
|
||||
}
|
||||
}
|
||||
return dst;
|
||||
}
|
||||
}
|
||||
}
|
||||
335
Legacy/System98/ImageG.cs
Normal file
335
Legacy/System98/ImageG.cs
Normal file
@@ -0,0 +1,335 @@
|
||||
//! \file ImageG.cs
|
||||
//! \date 2023 Oct 15
|
||||
//! \brief System-98 engine image format (PC-98).
|
||||
//
|
||||
// Copyright (C) 2023 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 GameRes.Utility;
|
||||
using System;
|
||||
using System.ComponentModel.Composition;
|
||||
using System.IO;
|
||||
using System.Windows.Media;
|
||||
|
||||
// [951216][Four-Nine] Lilith
|
||||
|
||||
namespace GameRes.Formats.System98
|
||||
{
|
||||
[Export(typeof(ImageFormat))]
|
||||
public class GFormat : ImageFormat
|
||||
{
|
||||
public override string Tag => "G/SYSTEM98";
|
||||
public override string Description => "System-98 engine image format";
|
||||
public override uint Signature => 0;
|
||||
|
||||
public GFormat ()
|
||||
{
|
||||
Extensions = new[] { "g", "" };
|
||||
}
|
||||
|
||||
public override ImageMetaData ReadMetaData (IBinaryStream file)
|
||||
{
|
||||
if (file.Length < 61)
|
||||
return null;
|
||||
var header = file.ReadHeader (0xA);
|
||||
ushort width = Binary.BigEndian (header.ToUInt16 (6));
|
||||
ushort height = Binary.BigEndian (header.ToUInt16 (8));
|
||||
if (0 == width || 0 == height || (width & 7) != 0 || width > 640 || height > 400)
|
||||
return null;
|
||||
return new ImageMetaData {
|
||||
Width = width,
|
||||
Height = height,
|
||||
BPP = 4,
|
||||
};
|
||||
}
|
||||
|
||||
public override ImageData Read (IBinaryStream file, ImageMetaData info)
|
||||
{
|
||||
file.Position = 0xA;
|
||||
var palette = ReadPalette (file.AsStream, 16, PaletteFormat.Rgb);
|
||||
var reader = new GraBaseReader (file, info);
|
||||
reader.UnpackBits();
|
||||
return ImageData.Create (info, PixelFormats.Indexed4, palette, reader.Pixels, reader.Stride);
|
||||
}
|
||||
|
||||
public override void Write (Stream file, ImageData image)
|
||||
{
|
||||
throw new System.NotImplementedException ("GFormat.Write not implemented");
|
||||
}
|
||||
}
|
||||
|
||||
internal class GraBaseReader
|
||||
{
|
||||
protected IBinaryStream m_input;
|
||||
protected ImageMetaData m_info;
|
||||
protected int m_output_stride;
|
||||
protected byte[] m_pixels;
|
||||
|
||||
public byte[] Pixels => m_pixels;
|
||||
public int Stride => m_output_stride;
|
||||
|
||||
public GraBaseReader (IBinaryStream file, ImageMetaData info)
|
||||
{
|
||||
m_input = file;
|
||||
m_info = info;
|
||||
m_output_stride = m_info.iWidth >> 1;
|
||||
m_pixels = new byte[m_output_stride * m_info.iHeight];
|
||||
}
|
||||
|
||||
ushort[] m_buffer;
|
||||
|
||||
public void UnpackBits ()
|
||||
{
|
||||
try
|
||||
{
|
||||
UnpackBitsInternal();
|
||||
}
|
||||
catch (EndOfStreamException)
|
||||
{
|
||||
FlushBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
void UnpackBitsInternal ()
|
||||
{
|
||||
int width = m_info.iWidth;
|
||||
int wTimes2 = width << 1;
|
||||
int wTimes4 = width << 2;
|
||||
int buffer_size = wTimes4 + wTimes2;
|
||||
m_buffer = new ushort[buffer_size >> 1];
|
||||
m_dst = 0;
|
||||
InitFrame();
|
||||
InitBitReader();
|
||||
ushort p = ReadPair (0);
|
||||
for (int i = 0; i < width; ++i)
|
||||
m_buffer[i] = p;
|
||||
int dst = wTimes2;
|
||||
int prev_src = 0;
|
||||
while (m_dst < m_pixels.Length)
|
||||
{
|
||||
bool same_line = false;
|
||||
int src = -width;
|
||||
if (GetNextBit() != 0)
|
||||
{
|
||||
if (GetNextBit() == 0)
|
||||
src <<= 1;
|
||||
else if (GetNextBit() == 0)
|
||||
src += 1;
|
||||
else
|
||||
src -= 1;
|
||||
}
|
||||
else if (GetNextBit() == 0)
|
||||
{
|
||||
src = -4;
|
||||
p = m_buffer[dst/2-1];
|
||||
if ((p & 0xFF) == (p >> 8))
|
||||
same_line = src != prev_src;
|
||||
}
|
||||
if (src != prev_src)
|
||||
{
|
||||
prev_src = src;
|
||||
if (!same_line)
|
||||
src += dst;
|
||||
else
|
||||
src = dst - 2;
|
||||
if (GetNextBit() != 0)
|
||||
{
|
||||
int bitlength = 0;
|
||||
do
|
||||
{
|
||||
++bitlength;
|
||||
}
|
||||
while (GetNextBit() != 0);
|
||||
int count = 1;
|
||||
while (bitlength --> 0)
|
||||
count = count << 1 | GetNextBit();
|
||||
int remaining = (buffer_size - dst) >> 1;
|
||||
while (count > remaining)
|
||||
{
|
||||
count -= remaining;
|
||||
MovePixels (m_buffer, src, dst, remaining);
|
||||
src += remaining << 1;
|
||||
if (FlushBuffer())
|
||||
return;
|
||||
dst = wTimes2;
|
||||
src -= wTimes4;
|
||||
remaining = wTimes4 >> 1;
|
||||
}
|
||||
MovePixels (m_buffer, src, dst, count);
|
||||
dst += count << 1;
|
||||
if (dst == buffer_size)
|
||||
{
|
||||
if (FlushBuffer())
|
||||
return;
|
||||
dst = wTimes2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
MovePixels (m_buffer, src, dst, 1);
|
||||
dst += 2;
|
||||
if (dst == buffer_size)
|
||||
{
|
||||
if (FlushBuffer())
|
||||
return;
|
||||
dst = wTimes2;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
p = m_buffer[dst/2-1];
|
||||
do
|
||||
{
|
||||
byte prev = (byte)(p >> 8);
|
||||
p = ReadPair (prev);
|
||||
m_buffer[dst >> 1] = p;
|
||||
dst += 2;
|
||||
if (dst == buffer_size)
|
||||
{
|
||||
if (FlushBuffer())
|
||||
return;
|
||||
dst = wTimes2;
|
||||
}
|
||||
}
|
||||
while (GetNextBit() != 0);
|
||||
prev_src = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int m_dst;
|
||||
|
||||
bool FlushBuffer ()
|
||||
{
|
||||
MovePixels (m_buffer, m_info.iWidth * 4, 0, m_info.iWidth);
|
||||
int src = m_info.iWidth;
|
||||
int count = Math.Min (m_info.iWidth << 1, m_pixels.Length - m_dst);
|
||||
while (count --> 0)
|
||||
{
|
||||
ushort p = m_buffer[src++];
|
||||
m_pixels[m_dst++] = (byte)((p & 0xF0) | p >> 12);
|
||||
}
|
||||
return m_dst == m_pixels.Length;
|
||||
}
|
||||
|
||||
ushort ReadPair (int pos)
|
||||
{
|
||||
byte al = ReadPixel (pos);
|
||||
byte ah = ReadPixel (al);
|
||||
return (ushort)(al | ah << 8);
|
||||
}
|
||||
|
||||
byte ReadPixel (int pos)
|
||||
{
|
||||
byte px = 0;
|
||||
if (GetNextBit() == 0)
|
||||
{
|
||||
int count = 1;
|
||||
if (GetNextBit() != 0)
|
||||
{
|
||||
if (GetNextBit() != 0)
|
||||
{
|
||||
count = count << 1 | GetNextBit();
|
||||
}
|
||||
count = count << 1 | GetNextBit();
|
||||
}
|
||||
count = count << 1 | GetNextBit();
|
||||
pos += count;
|
||||
px = m_frame[pos--];
|
||||
while (count --> 0)
|
||||
{
|
||||
m_frame[pos+1] = m_frame[pos];
|
||||
--pos;
|
||||
}
|
||||
m_frame[pos+1] = px;
|
||||
}
|
||||
else if (GetNextBit() == 0)
|
||||
{
|
||||
px = m_frame[pos];
|
||||
}
|
||||
else
|
||||
{
|
||||
px = m_frame[pos+1];
|
||||
m_frame[pos+1] = m_frame[pos];
|
||||
m_frame[pos] = px;
|
||||
}
|
||||
return px;
|
||||
}
|
||||
|
||||
byte[] m_frame;
|
||||
|
||||
void InitFrame ()
|
||||
{
|
||||
m_frame = new byte[0x100];
|
||||
int p = 0;
|
||||
byte a = 0;
|
||||
for (int j = 0; j < 0x10; ++j)
|
||||
{
|
||||
for (int i = 0; i < 0x10; ++i)
|
||||
{
|
||||
m_frame[p++] = a;
|
||||
a -= 0x10;
|
||||
}
|
||||
a += 0x10;
|
||||
}
|
||||
}
|
||||
|
||||
void MovePixels (ushort[] pixels, int src, int dst, int count)
|
||||
{
|
||||
count <<= 1;
|
||||
if (dst > src)
|
||||
{
|
||||
while (count > 0)
|
||||
{
|
||||
int preceding = Math.Min (dst - src, count);
|
||||
Buffer.BlockCopy (pixels, src, pixels, dst, preceding);
|
||||
dst += preceding;
|
||||
count -= preceding;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Buffer.BlockCopy (pixels, src, pixels, dst, count);
|
||||
}
|
||||
}
|
||||
|
||||
int m_bits;
|
||||
int m_bit_count;
|
||||
|
||||
void InitBitReader ()
|
||||
{
|
||||
m_bit_count = 1;
|
||||
}
|
||||
|
||||
byte GetNextBit ()
|
||||
{
|
||||
if (--m_bit_count <= 0)
|
||||
{
|
||||
m_bits = m_input.ReadUInt8();
|
||||
m_bit_count = 8;
|
||||
}
|
||||
int bit = (m_bits >> 7) & 1;
|
||||
m_bits <<= 1;
|
||||
return (byte)bit;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user