1
0
mirror of https://github.com/crskycode/GARbro.git synced 2024-12-25 04:14:13 +08:00

641 lines
22 KiB
C#
Raw Normal View History

//! \file ArcNSA.cs
//! \date Sun Jul 27 11:25:46 2014
2015-09-01 03:38:04 +04:00
//! \brief NScripter NSA archives implementation.
//
2015-09-01 03:38:04 +04:00
// Copyright (C) 2014-2015 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.Collections.Generic;
using System.ComponentModel.Composition;
2015-09-01 03:38:04 +04:00
using System.Text;
using GameRes.Formats.Strings;
2015-09-01 03:38:04 +04:00
using GameRes.Utility;
2018-04-20 21:18:27 +04:00
using ICSharpCode.SharpZipLib.BZip2;
2015-09-01 03:38:04 +04:00
namespace GameRes.Formats.NScripter
{
public class NsaEntry : PackedEntry
{
public Compression CompressionType { get; set; }
}
2015-09-01 03:38:04 +04:00
internal class NsaEncryptedArchive : ArcFile
{
public readonly byte[] Key;
public NsaEncryptedArchive (ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, byte[] key)
: base (arc, impl, dir)
{
Key = key;
}
}
public class NsaOptions : ResourceOptions
{
public Compression CompressionType { get; set; }
2015-09-01 03:38:04 +04:00
public string Password { get; set; }
}
[Serializable]
public class NsaScheme : ResourceScheme
{
public Dictionary<string, string> KnownKeys;
}
public enum Compression
{
Unknown = 256,
None = 0,
SPB = 1,
LZSS = 2,
NBZ = 4,
}
[Export(typeof(ArchiveFormat))]
2015-09-01 03:38:04 +04:00
public class NsaOpener : SarOpener
{
2015-09-01 03:38:04 +04:00
public override string Tag { get { return "NSA"; } }
2015-09-01 03:38:04 +04:00
public NsaOpener ()
{
Extensions = new string[] { "nsa", "dat" };
}
public static Dictionary<string, string> KnownKeys = new Dictionary<string, string>();
public override ResourceScheme Scheme
{
get { return new NsaScheme { KnownKeys = KnownKeys }; }
set { KnownKeys = ((NsaScheme)value).KnownKeys; }
}
2015-09-01 03:38:04 +04:00
public override ArcFile TryOpen (ArcView file)
{
2015-09-01 03:38:04 +04:00
List<Entry> dir = null;
bool zero_signature = 0 == file.View.ReadInt16 (0);
try
{
using (var input = file.CreateStream())
{
2015-09-01 03:38:04 +04:00
if (zero_signature)
input.Seek (2, SeekOrigin.Begin);
dir = ReadIndex (input);
if (null != dir)
return new ArcFile (file, this, dir);
}
}
2015-09-01 03:38:04 +04:00
catch { /* ignore parse errors */ }
if (zero_signature || !file.Name.HasExtension (".nsa"))
2015-09-01 03:38:04 +04:00
return null;
uint signature = file.View.ReadUInt32 (0);
if ((signature & 0xFFFFFF) == 0x90FBFF) // looks like mp3 file
return new WrapSingleFileArchive (file, Path.GetFileNameWithoutExtension (file.Name)+".mp3");
2015-09-01 03:38:04 +04:00
var password = QueryPassword();
if (string.IsNullOrEmpty (password))
return null;
var key = Encoding.ASCII.GetBytes (password);
using (var input = new EncryptedViewStream (file, key))
{
2015-09-01 03:38:04 +04:00
dir = ReadIndex (input);
if (null == dir)
return null;
return new NsaEncryptedArchive (file, this, dir, key);
}
}
2015-09-01 03:38:04 +04:00
protected List<Entry> ReadIndex (Stream file)
{
2015-09-01 03:38:04 +04:00
long base_offset = file.Position;
using (var input = new ArcView.Reader (file))
{
2015-09-01 03:38:04 +04:00
int count = Binary.BigEndian (input.ReadInt16());
if (!IsSaneCount (count))
return null;
base_offset += Binary.BigEndian (input.ReadUInt32());
if (base_offset >= file.Length || base_offset < 15 * count)
return null;
var dir = new List<Entry>();
for (int i = 0; i < count; ++i)
{
2015-09-01 03:38:04 +04:00
if (base_offset - file.Position < 15)
return null;
var name = file.ReadCString();
if (base_offset - file.Position < 13 || 0 == name.Length)
2015-09-01 03:38:04 +04:00
return null;
var entry = FormatCatalog.Instance.Create<NsaEntry> (name);
byte compression_type = input.ReadByte();
entry.Offset = Binary.BigEndian (input.ReadUInt32()) + base_offset;
entry.Size = Binary.BigEndian (input.ReadUInt32());
if (!entry.CheckPlacement (file.Length))
return null;
entry.UnpackedSize = Binary.BigEndian (input.ReadUInt32());
entry.IsPacked = compression_type != 0;
switch (compression_type)
{
case 0: entry.CompressionType = Compression.None; break;
case 1: entry.CompressionType = Compression.SPB; break;
case 2: entry.CompressionType = Compression.LZSS; break;
case 4: entry.CompressionType = Compression.NBZ; break;
default: entry.CompressionType = Compression.Unknown; break;
}
2018-04-20 21:18:27 +04:00
if (name.HasExtension (".nbz"))
entry.Type = "audio";
2015-09-01 03:38:04 +04:00
dir.Add (entry);
}
2015-09-01 03:38:04 +04:00
return dir;
}
}
2015-09-01 03:38:04 +04:00
public override Stream OpenEntry (ArcFile arc, Entry entry)
{
2015-09-01 03:38:04 +04:00
var nsa_arc = arc as NsaEncryptedArchive;
if (null == nsa_arc)
{
var input = arc.File.CreateStream (entry.Offset, entry.Size);
return UnpackEntry (input, entry as NsaEntry);
}
var encrypted = new EncryptedViewStream (arc.File, nsa_arc.Key);
var stream = new StreamRegion (encrypted, entry.Offset, entry.Size);
return UnpackEntry (stream, entry as NsaEntry);
}
2015-09-01 03:38:04 +04:00
protected Stream UnpackEntry (Stream input, NsaEntry nsa_entry)
{
2018-04-20 21:18:27 +04:00
if (null == nsa_entry)
return input;
if (nsa_entry.Name.HasExtension (".nbz") || Compression.NBZ == nsa_entry.CompressionType)
2018-04-20 21:18:27 +04:00
{
input.Position = 4;
return new BZip2InputStream (input);
}
if (!(Compression.LZSS == nsa_entry.CompressionType ||
Compression.SPB == nsa_entry.CompressionType))
2015-09-01 03:38:04 +04:00
return input;
using (input)
{
2015-09-01 03:38:04 +04:00
var decoder = new Unpacker (input, nsa_entry.UnpackedSize);
if (Compression.SPB == nsa_entry.CompressionType)
return decoder.SpbDecodedStream();
else
return decoder.LzssDecodedStream();
}
}
2015-09-01 03:38:04 +04:00
private string QueryPassword ()
2014-07-29 14:50:29 +04:00
{
2015-09-01 03:38:04 +04:00
var options = Query<NsaOptions> (arcStrings.ArcEncryptedNotice);
return options.Password;
2014-07-29 14:50:29 +04:00
}
public override ResourceOptions GetDefaultOptions ()
{
return new NsaOptions {
CompressionType = Properties.Settings.Default.ONSCompression,
Password = Properties.Settings.Default.NSAPassword,
};
}
2015-09-01 03:38:04 +04:00
public override ResourceOptions GetOptions (object widget)
{
var w = widget as GUI.WidgetNSA;
if (null != w)
Properties.Settings.Default.NSAPassword = w.Password.Text;
2015-09-01 03:38:04 +04:00
return GetDefaultOptions();
}
public override object GetAccessWidget ()
{
return new GUI.WidgetNSA (KnownKeys);
2015-09-01 03:38:04 +04:00
}
public override object GetCreationWidget ()
{
return new GUI.CreateONSWidget();
}
public override void Create (Stream output, IEnumerable<Entry> list, ResourceOptions options,
EntryCallback callback)
{
var ons_options = GetOptions<NsaOptions> (options);
var encoding = Encodings.cp932.WithFatalFallback();
int callback_count = 0;
var real_entry_list = new List<NsaEntry>();
var used_names = new HashSet<string>();
int index_size = 0;
foreach (var entry in list)
{
if (!used_names.Add (entry.Name)) // duplicate name
continue;
try
{
index_size += encoding.GetByteCount (entry.Name) + 1;
}
catch (EncoderFallbackException X)
{
throw new InvalidFileName (entry.Name, arcStrings.MsgIllegalCharacters, X);
}
var header_entry = new NsaEntry { Name = entry.Name };
2014-07-29 14:50:29 +04:00
if (Compression.None != ons_options.CompressionType)
{
if (entry.Name.HasExtension (".bmp"))
2014-07-29 14:50:29 +04:00
header_entry.CompressionType = ons_options.CompressionType;
}
index_size += 13;
real_entry_list.Add (header_entry);
}
long start_offset = output.Position;
long base_offset = 6+index_size;
output.Seek (base_offset, SeekOrigin.Current);
foreach (var entry in real_entry_list)
{
using (var input = File.OpenRead (entry.Name))
{
var file_size = input.Length;
if (file_size > uint.MaxValue)
throw new FileSizeException();
long file_offset = output.Position - base_offset;
if (file_offset+file_size > uint.MaxValue)
throw new FileSizeException();
if (null != callback)
callback (callback_count++, entry, arcStrings.MsgAddingFile);
2014-07-29 14:50:29 +04:00
entry.Offset = file_offset;
entry.UnpackedSize = (uint)file_size;
if (Compression.LZSS == entry.CompressionType)
{
var packer = new Packer (input, output);
entry.Size = packer.EncodeLZSS();
}
else
{
entry.Size = entry.UnpackedSize;
entry.CompressionType = Compression.None;
input.CopyTo (output);
}
}
}
if (null != callback)
callback (callback_count++, null, arcStrings.MsgWritingIndex);
output.Position = start_offset;
using (var writer = new BinaryWriter (output, encoding, true))
{
writer.Write (Binary.BigEndian ((short)real_entry_list.Count));
writer.Write (Binary.BigEndian ((uint)base_offset));
foreach (var entry in real_entry_list)
{
writer.Write (encoding.GetBytes (entry.Name));
writer.Write ((byte)0);
writer.Write ((byte)entry.CompressionType);
writer.Write (Binary.BigEndian ((uint)entry.Offset));
writer.Write (Binary.BigEndian ((uint)entry.Size));
writer.Write (Binary.BigEndian ((uint)entry.UnpackedSize));
}
}
}
}
/*
* ONScripter-EN decompression routines.
*
* Copyright (c) 2001-2010 Ogapee. All rights reserved.
* (original ONScripter, of which this is a fork).
*
* ogapee@aqua.dti2.ne.jp
*
* Copyright (c) 2007-2010 "Uncle" Mion Sonozaki
*
* UncleMion@gmail.com
*
*/
2014-07-29 14:50:29 +04:00
/* LZSS encoder-decoder (c) Haruhiko Okumura */
internal static class LZSS
{
public const int EI = 8;
public const int EJ = 4;
public const int P = 1; /* If match length <= P then output one character */
public const int N = (1 << EI); /* buffer size */
public const int F = ((1 << EJ) + P); /* lookahead buffer size */
}
2015-09-01 03:38:04 +04:00
internal class Unpacker : MsbBitStream
{
private byte[] m_output;
2015-09-01 03:38:04 +04:00
public byte[] Output { get { return m_output; } }
public Unpacker (Stream input, uint unpacked_size) : base (input, true)
{
m_output = new byte[unpacked_size];
}
public Stream LzssDecodedStream ()
{
2015-09-01 03:38:04 +04:00
DecodeLZSS();
return new MemoryStream (m_output);
}
public Stream SpbDecodedStream ()
{
2015-09-01 03:38:04 +04:00
DecodeSPB();
return new MemoryStream (m_output);
}
uint DecodeLZSS ()
{
uint count = 0;
2014-07-29 14:50:29 +04:00
byte[] decomp_buffer = new byte[LZSS.N*2];
int r = LZSS.N - LZSS.F;
int c;
while (count < m_output.Length)
{
if (0 != GetBits (1))
{
c = GetBits (8);
if (-1 == c)
break;
m_output[count++] = (byte)c;
decomp_buffer[r++] = (byte)c;
2014-07-29 14:50:29 +04:00
r &= (LZSS.N - 1);
}
else
{
2014-07-29 14:50:29 +04:00
int i = GetBits (LZSS.EI);
if (-1 == i)
break;
2014-07-29 14:50:29 +04:00
int j = GetBits (LZSS.EJ);
if (-1 == j)
break;
for (int k = 0; k <= j + 1; k++)
{
2014-07-29 14:50:29 +04:00
c = decomp_buffer[(i + k) & (LZSS.N - 1)];
m_output[count++] = (byte)c;
decomp_buffer[r++] = (byte)c;
2014-07-29 14:50:29 +04:00
r &= (LZSS.N - 1);
}
}
}
return count;
}
uint DecodeSPB ()
{
2015-09-01 03:38:04 +04:00
uint width = (uint)Input.ReadByte() << 8;
width |= (uint)Input.ReadByte();
uint height = (uint)Input.ReadByte() << 8;
height |= (uint)Input.ReadByte();
uint width_pad = (4 - width * 3 % 4) % 4;
int stride = (int)(width * 3 + width_pad);
uint total_size = (uint)stride * height + 54;
if ((uint)m_output.Length < total_size)
m_output = new byte[total_size];
/* ---------------------------------------- */
/* Write header */
m_output[0] = (byte)'B';
m_output[1] = (byte)'M';
2015-09-01 03:38:04 +04:00
LittleEndian.Pack (total_size, m_output, 2);
m_output[10] = 54; // offset to the body
m_output[14] = 40; // header size
2015-09-01 03:38:04 +04:00
LittleEndian.Pack (width, m_output, 18);
LittleEndian.Pack (height, m_output, 22);
m_output[26] = 1; // the number of the plane
m_output[28] = 24; // bpp
byte[] decomp_buffer = new byte[width*height*4];
for (int i = 0; i < 3; i++)
{
uint count = 0;
int c = GetBits (8);
if (-1 == c)
break;
decomp_buffer[count++] = (byte)c;
while (count < width * height)
{
int n = GetBits (3);
if (0 == n)
{
decomp_buffer[count++] = (byte)c;
decomp_buffer[count++] = (byte)c;
decomp_buffer[count++] = (byte)c;
decomp_buffer[count++] = (byte)c;
continue;
}
int m;
if (7 == n)
m = GetBits (1) + 1;
else
m = n + 2;
for (uint j = 0; j < 4; j++)
{
if (8 == m)
{
c = GetBits (8);
}
else
{
int k = GetBits (m);
if (0 != (k & 1))
c += (k>>1) + 1;
else
c -= (k>>1);
}
decomp_buffer[count++] = (byte)c;
}
}
int pbuf = stride * (int)(height-1) + i + 54; // in m_output
int psbuf = 0; // in decomp_buffer
for (uint j = 0; j < height; j++)
{
if (0 != (j & 1))
{
for (uint k = 0; k < width; k++, pbuf -= 3)
m_output[pbuf] = decomp_buffer[psbuf++];
pbuf -= stride - 3;
}
else
{
for (uint k = 0; k < width; k++, pbuf += 3)
m_output[pbuf] = decomp_buffer[psbuf++];
pbuf -= stride + 3;
}
}
}
return total_size;
}
}
2014-07-29 14:50:29 +04:00
internal class Packer
{
private Stream m_input;
private Stream m_output;
private uint m_code_count = 0;
public uint PackedSize { get { return m_code_count; } }
public Packer (Stream input, Stream output)
{
m_input = input;
m_output = output;
}
public uint EncodeLZSS ()
{
byte[] comp_buffer = new byte[LZSS.N*2];
int i;
for (i = LZSS.N - LZSS.F; i < LZSS.N * 2; i++)
{
int c = m_input.ReadByte();
if (-1 == c)
break;
comp_buffer[i] = (byte)c;
}
int bufferend = i;
int r = LZSS.N - LZSS.F;
int s = 0;
while (r < bufferend)
{
int f1 = (LZSS.F <= bufferend - r) ? LZSS.F : bufferend - r;
int x = 0;
int y = 1;
int c = comp_buffer[r];
for (i = r - 1; i >= s; i--)
{
if (comp_buffer[i] == c)
{
int j;
for (j = 1; j < f1; j++)
if (comp_buffer[i + j] != comp_buffer[r + j])
break;
if (j > y)
{
x = i;
y = j;
}
}
}
if (y <= LZSS.P)
Output1 (c);
else
Output2 (x & (LZSS.N - 1), y - 2);
r += y;
s += y;
if (r >= LZSS.N * 2 - LZSS.F)
{
for (i = 0; i < LZSS.N; i++)
comp_buffer[i] = comp_buffer[i + LZSS.N];
bufferend -= LZSS.N;
r -= LZSS.N;
s -= LZSS.N;
while (bufferend < LZSS.N * 2)
{
c = m_input.ReadByte();
if (-1 == c)
break;
comp_buffer[bufferend++] = (byte)c;
}
}
}
FlushBitBuffer();
return m_code_count;
}
int m_bit_buffer = 0;
int m_bit_mask = 128;
void PutBit1 ()
{
m_bit_buffer |= m_bit_mask;
if ((m_bit_mask >>= 1) == 0)
{
m_output.WriteByte ((byte)m_bit_buffer);
m_bit_buffer = 0;
m_bit_mask = 128;
m_code_count++;
}
}
void PutBit0 ()
{
if ((m_bit_mask >>= 1) == 0)
{
m_output.WriteByte ((byte)m_bit_buffer);
m_bit_buffer = 0;
m_bit_mask = 128;
m_code_count++;
}
}
void FlushBitBuffer ()
{
if (m_bit_mask != 128)
{
m_output.WriteByte ((byte)m_bit_buffer);
m_code_count++;
}
}
void Output1 (int c)
{
PutBit1();
int mask = 256;
while (0 != (mask >>= 1))
{
if (0 != (c & mask)) PutBit1();
else PutBit0();
}
}
void Output2 (int x, int y)
{
PutBit0();
int mask = LZSS.N;
while (0 != (mask >>= 1))
{
if (0 != (x & mask)) PutBit1();
else PutBit0();
}
mask = (1 << LZSS.EJ);
while (0 != (mask >>= 1))
{
if (0 != (y & mask)) PutBit1();
else PutBit0();
}
}
}
}