mirror of
https://github.com/crskycode/GARbro.git
synced 2024-11-27 15:44:00 +08:00
441 lines
16 KiB
C#
441 lines
16 KiB
C#
//! \file ArcTCD3.cs
|
|
//! \date Thu Oct 08 13:14:57 2015
|
|
//! \brief TopCat data archives (TCD)
|
|
//
|
|
// Copyright (C) 2015-2016 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.Collections.Generic;
|
|
using System.ComponentModel.Composition;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using GameRes.Utility;
|
|
|
|
namespace GameRes.Formats.TopCat
|
|
{
|
|
internal class TcdSection
|
|
{
|
|
public string Extension;
|
|
public uint DataSize;
|
|
public uint IndexOffset;
|
|
public int DirCount;
|
|
public int DirNameLength;
|
|
public int FileCount;
|
|
public int FileNameLength;
|
|
|
|
public int DirNamesSize;
|
|
public int FileNamesSize;
|
|
}
|
|
|
|
internal struct TcdDirEntry
|
|
{
|
|
public int FileCount;
|
|
public int NamesOffset;
|
|
public int FirstIndex;
|
|
}
|
|
|
|
internal class TcdEntry : Entry
|
|
{
|
|
public int Index;
|
|
}
|
|
|
|
internal class TcdArchive : ArcFile
|
|
{
|
|
public int? Key;
|
|
|
|
public TcdArchive (ArcView arc, ArchiveFormat impl, ICollection<Entry> dir)
|
|
: base (arc, impl, dir)
|
|
{
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class TcdScheme : ResourceScheme
|
|
{
|
|
public Dictionary<string, int> KnownKeys;
|
|
}
|
|
|
|
[Export(typeof(ArchiveFormat))]
|
|
public class TcdOpener : ArchiveFormat
|
|
{
|
|
public override string Tag { get { return "TCD"; } }
|
|
public override string Description { get { return "TopCat data archive"; } }
|
|
public override uint Signature { get { return 0x33444354; } } // 'TCD3'
|
|
public override bool IsHierarchic { get { return true; } }
|
|
public override bool CanWrite { get { return false; } }
|
|
|
|
public TcdOpener ()
|
|
{
|
|
Signatures = new uint[] { 0x32444354, 0x33444354 }; // 'TCD2', 'TCD3'
|
|
}
|
|
|
|
public static Dictionary<string, int> KnownKeys = new Dictionary<string, int>();
|
|
|
|
public override ResourceScheme Scheme
|
|
{
|
|
get { return new TcdScheme { KnownKeys = KnownKeys }; }
|
|
set { KnownKeys = ((TcdScheme)value).KnownKeys; }
|
|
}
|
|
|
|
public override ArcFile TryOpen (ArcView file)
|
|
{
|
|
int version = file.View.ReadByte (3) - '0';
|
|
TcdIndexReader reader;
|
|
if (2 == version)
|
|
reader = new TcdReaderV2 (file);
|
|
else
|
|
reader = new TcdReaderV3 (file);
|
|
using (reader)
|
|
{
|
|
var dir = reader.ReadIndex();
|
|
if (null == dir)
|
|
return null;
|
|
return new TcdArchive (file, this, dir);
|
|
}
|
|
}
|
|
|
|
public override Stream OpenEntry (ArcFile arc, Entry entry)
|
|
{
|
|
if (entry.Name.EndsWith (".OGG", StringComparison.InvariantCultureIgnoreCase))
|
|
return RestoreOggStream (arc, entry);
|
|
if (entry.Name.EndsWith (".TSF", StringComparison.InvariantCultureIgnoreCase) ||
|
|
entry.Name.EndsWith (".TCT", StringComparison.InvariantCultureIgnoreCase))
|
|
return OpenScript (arc, entry);
|
|
if (entry.Name.EndsWith (".SPD", StringComparison.InvariantCultureIgnoreCase))
|
|
return OpenSpdc (arc, entry);
|
|
return arc.File.CreateStream (entry.Offset, entry.Size);
|
|
}
|
|
|
|
Stream OpenSpdc (ArcFile arc, Entry entry)
|
|
{
|
|
int signature = arc.File.View.ReadInt32 (entry.Offset);
|
|
if (0x43445053 == signature || 0x38445053 == signature || entry.Size <= 0x14)
|
|
return arc.File.CreateStream (entry.Offset, entry.Size);
|
|
|
|
var header = arc.File.View.ReadBytes (entry.Offset, 0x14);
|
|
byte header_key = (byte)(header[0x12] + header[0x10]);
|
|
header[0] -= header_key;
|
|
header[1] -= header_key;
|
|
header[2] -= header_key;
|
|
header[3] -= header_key;
|
|
bool spdc_entry = Binary.AsciiEqual (header, "SPD") && (header[3] == 'C' || header[3] == '8');
|
|
if (!spdc_entry)
|
|
{
|
|
LittleEndian.Pack (signature, header, 0);
|
|
var tcde = entry as TcdEntry;
|
|
var tcda = arc as TcdArchive;
|
|
if (tcda != null && tcde != null)
|
|
{
|
|
if (null == tcda.Key)
|
|
{
|
|
foreach (var key in TcdOpener.KnownKeys.Values)
|
|
{
|
|
int first = signature + key * (tcde.Index + 3);
|
|
if (0x43445053 == first) // 'SPDC'
|
|
{
|
|
tcda.Key = key;
|
|
spdc_entry = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (0x43445053 == (signature + tcda.Key.Value * (tcde.Index + 3)))
|
|
{
|
|
spdc_entry = true;
|
|
}
|
|
if (spdc_entry && 0 != tcda.Key.Value)
|
|
{
|
|
unsafe
|
|
{
|
|
fixed (byte* raw = header)
|
|
{
|
|
int* dw = (int*)raw;
|
|
for (int i = 0; i < 5; ++i)
|
|
dw[i] += tcda.Key.Value * (tcde.Index + 3 + i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var rest = arc.File.CreateStream (entry.Offset+0x14, entry.Size-0x14);
|
|
return new PrefixStream (header, rest);
|
|
}
|
|
|
|
Stream OpenScript (ArcFile arc, Entry entry)
|
|
{
|
|
int unpacked_size = arc.File.View.ReadInt32 (entry.Offset);
|
|
byte[] data = new byte[unpacked_size];
|
|
using (var input = arc.File.CreateStream (entry.Offset+4, entry.Size-4))
|
|
UnpackLz (input, data);
|
|
DecryptScript (data);
|
|
return new MemoryStream (data);
|
|
}
|
|
|
|
void UnpackLz (Stream input, byte[] output)
|
|
{
|
|
int dst = 0;
|
|
int bits = 2;
|
|
while (dst < output.Length)
|
|
{
|
|
bits >>= 1;
|
|
if (1 == bits)
|
|
{
|
|
bits = input.ReadByte();
|
|
if (-1 == bits)
|
|
break;
|
|
bits |= 0x100;
|
|
}
|
|
if (0 == (bits & 1))
|
|
{
|
|
int count = input.ReadByte();
|
|
int offset = input.ReadByte() << 4 | count >> 4;
|
|
count = Math.Min ((count & 0xF) + 3, output.Length - dst);
|
|
Binary.CopyOverlapped (output, dst-offset, dst, count);
|
|
dst += count;
|
|
}
|
|
else
|
|
{
|
|
output[dst++] = (byte)input.ReadByte();
|
|
}
|
|
}
|
|
}
|
|
|
|
void DecryptScript (byte[] data)
|
|
{
|
|
for (int i = 0; i < data.Length; ++i)
|
|
data[i] = Binary.RotByteR (data[i], 1);
|
|
}
|
|
|
|
Stream RestoreOggStream (ArcFile arc, Entry entry)
|
|
{
|
|
var data = arc.File.View.ReadBytes (entry.Offset, entry.Size);
|
|
int remaining = data.Length;
|
|
int src = 0;
|
|
while (remaining > 0x1B && Binary.AsciiEqual (data, src, "OggS"))
|
|
{
|
|
int segment_count = data[src+0x1A];
|
|
data[src+0x16] = 0;
|
|
data[src+0x17] = 0;
|
|
data[src+0x18] = 0;
|
|
data[src+0x19] = 0;
|
|
int page_size = segment_count + 0x1B;
|
|
if (segment_count != 0)
|
|
{
|
|
if (remaining < page_size)
|
|
break;
|
|
int segment_table = src + 0x1B;
|
|
for (int i = 0; i < segment_count; ++i)
|
|
page_size += data[segment_table++];
|
|
}
|
|
remaining -= page_size;
|
|
if (remaining < 0)
|
|
break;
|
|
uint crc = Crc32Normal.UpdateCrc (0, data, src, page_size);
|
|
LittleEndian.Pack (crc, data, src+0x16);
|
|
src += page_size;
|
|
}
|
|
return new MemoryStream (data);
|
|
}
|
|
}
|
|
|
|
internal abstract class TcdIndexReader : IDisposable
|
|
{
|
|
BinaryReader m_input;
|
|
int m_section_count;
|
|
|
|
public int Count { get; private set; }
|
|
protected BinaryReader Input { get { return m_input; } }
|
|
|
|
protected TcdIndexReader (ArcView file, int section_count)
|
|
{
|
|
Count = file.View.ReadInt32 (4);
|
|
var input = file.CreateStream();
|
|
m_input = new BinaryReader (input);
|
|
m_section_count = section_count;
|
|
}
|
|
|
|
protected string[] Extensions = { ".TCT", ".TSF", ".SPD", ".OGG", ".WAV" };
|
|
|
|
public List<Entry> ReadIndex ()
|
|
{
|
|
if (!ArchiveFormat.IsSaneCount (Count))
|
|
return null;
|
|
|
|
var sections = ReadSections (m_section_count);
|
|
var list = new List<Entry> (Count);
|
|
foreach (var section in sections)
|
|
{
|
|
m_input.BaseStream.Position = section.IndexOffset;
|
|
var dir_names = m_input.ReadBytes (section.DirNamesSize);
|
|
if (section.DirNamesSize != dir_names.Length)
|
|
return null;
|
|
byte section_key = dir_names[section.DirNameLength-1];
|
|
DecryptNames (dir_names, section_key);
|
|
|
|
var dirs = new TcdDirEntry[section.DirCount];
|
|
for (int i = 0; i < dirs.Length; ++i)
|
|
{
|
|
dirs[i].FileCount = m_input.ReadInt32();
|
|
dirs[i].NamesOffset = m_input.ReadInt32();
|
|
dirs[i].FirstIndex = m_input.ReadInt32();
|
|
m_input.ReadInt32();
|
|
}
|
|
var file_names = m_input.ReadBytes (section.FileNamesSize);
|
|
if (file_names.Length != section.FileNamesSize)
|
|
return null;
|
|
DecryptNames (file_names, section_key);
|
|
|
|
var offsets = new uint[section.FileCount + 1];
|
|
for (int i = 0; i < offsets.Length; ++i)
|
|
{
|
|
offsets[i] = m_input.ReadUInt32();
|
|
}
|
|
|
|
int dir_name_offset = 0;
|
|
foreach (var dir in dirs)
|
|
{
|
|
string dir_name = GetName (dir_names, section.DirNameLength, ref dir_name_offset);
|
|
int index = dir.FirstIndex;
|
|
int name_offset = dir.NamesOffset;
|
|
for (int i = 0; i < dir.FileCount; ++i)
|
|
{
|
|
string name = GetName (file_names, section.FileNameLength, ref name_offset);
|
|
name = Path.Combine (dir_name, name);
|
|
name = Path.ChangeExtension (name, section.Extension);
|
|
var entry = FormatCatalog.Instance.Create<TcdEntry> (name);
|
|
entry.Offset = offsets[index];
|
|
entry.Size = offsets[index+1] - offsets[index];
|
|
entry.Index = index;
|
|
++index;
|
|
list.Add (entry);
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
IList<TcdSection> ReadSections (int count)
|
|
{
|
|
var sections = new List<TcdSection> (count);
|
|
uint current_offset = 8;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
m_input.BaseStream.Position = current_offset;
|
|
var section = ReadSection (i);
|
|
if (section != null)
|
|
sections.Add (section);
|
|
current_offset += 0x20;
|
|
}
|
|
return sections;
|
|
}
|
|
|
|
void DecryptNames (byte[] buffer, byte key)
|
|
{
|
|
for (int i = 0; i < buffer.Length; ++i)
|
|
buffer[i] -= key;
|
|
}
|
|
|
|
protected abstract TcdSection ReadSection (int number);
|
|
|
|
protected abstract string GetName (byte[] names, int name_length, ref int offset);
|
|
|
|
#region IDisposable Members
|
|
bool _disposed = false;
|
|
public void Dispose ()
|
|
{
|
|
if (!_disposed)
|
|
{
|
|
m_input.Dispose();
|
|
_disposed = true;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
internal class TcdReaderV2 : TcdIndexReader
|
|
{
|
|
public TcdReaderV2 (ArcView file) : base (file, 4)
|
|
{
|
|
}
|
|
|
|
protected override TcdSection ReadSection (int number)
|
|
{
|
|
uint data_size = Input.ReadUInt32();
|
|
if (0 == data_size)
|
|
return null;
|
|
var section = new TcdSection { DataSize = data_size };
|
|
section.Extension = Extensions[number];
|
|
section.FileCount = Input.ReadInt32();
|
|
section.DirCount = Input.ReadInt32();
|
|
section.IndexOffset = Input.ReadUInt32();
|
|
section.DirNameLength = Input.ReadInt32();
|
|
section.FileNameLength = Input.ReadInt32();
|
|
section.DirNamesSize = section.DirNameLength;
|
|
section.FileNamesSize = section.FileNameLength;
|
|
return section;
|
|
}
|
|
|
|
protected override string GetName (byte[] names, int name_length, ref int offset)
|
|
{
|
|
int name_end = Array.IndexOf<byte> (names, 0, offset);
|
|
if (-1 == name_end)
|
|
name_end = names.Length;
|
|
name_length = name_end - offset;
|
|
string name = Encodings.cp932.GetString (names, offset, name_length);
|
|
offset += name_length + 1;
|
|
return name;
|
|
}
|
|
}
|
|
|
|
internal class TcdReaderV3 : TcdIndexReader
|
|
{
|
|
public TcdReaderV3 (ArcView file) : base (file, 5)
|
|
{
|
|
}
|
|
|
|
protected override TcdSection ReadSection (int number)
|
|
{
|
|
uint data_size = Input.ReadUInt32();
|
|
uint index_offset = Input.ReadUInt32();
|
|
if (0 == index_offset)
|
|
return null;
|
|
var section = new TcdSection { DataSize = data_size };
|
|
section.Extension = Extensions[number];
|
|
section.IndexOffset = index_offset;
|
|
section.DirCount = Input.ReadInt32();
|
|
section.DirNameLength = Input.ReadInt32();
|
|
section.FileCount = Input.ReadInt32();
|
|
section.FileNameLength = Input.ReadInt32();
|
|
section.DirNamesSize = section.DirNameLength * section.DirCount;
|
|
section.FileNamesSize = section.FileNameLength * section.FileCount;
|
|
return section;
|
|
}
|
|
|
|
protected override string GetName (byte[] names, int name_length, ref int offset)
|
|
{
|
|
string name = Binary.GetCString (names, offset, name_length);
|
|
offset += name_length;
|
|
return name;
|
|
}
|
|
}
|
|
}
|