mirror of
https://github.com/crskycode/GARbro.git
synced 2024-11-27 07:34:00 +08:00
429 lines
17 KiB
C#
429 lines
17 KiB
C#
//! \file ArcAMI.cs
|
|
//! \date Thu Jul 03 09:40:40 2014
|
|
//! \brief Muv-Luv Amaterasu Translation archive.
|
|
//
|
|
// 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.Text;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Composition;
|
|
using System.Globalization;
|
|
using System.Windows;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
using ZLibNet;
|
|
using GameRes.Formats.Strings;
|
|
|
|
namespace GameRes.Formats
|
|
{
|
|
public class AmiEntry : PackedEntry
|
|
{
|
|
private Lazy<Tuple<string,string>> m_item;
|
|
public override string Name
|
|
{
|
|
get { return m_item.Value.Item1; }
|
|
set { m_item = new Lazy<Tuple<string, string>>(() => new Tuple<string, string>(value, Type)); }
|
|
}
|
|
public override string Type
|
|
{
|
|
get { return m_item.Value.Item2; }
|
|
set { m_item = new Lazy<Tuple<string, string>>(() => new Tuple<string, string>(Name, value)); }
|
|
}
|
|
|
|
public AmiEntry (Func<Tuple<string, string>> factory)
|
|
{
|
|
m_item = new Lazy<Tuple<string, string>> (factory);
|
|
}
|
|
}
|
|
|
|
[Export(typeof(ArchiveFormat))]
|
|
public class AmiOpener : ArchiveFormat
|
|
{
|
|
public override string Tag { get { return "AMI"; } }
|
|
public override string Description { get { return Strings.arcStrings.AMIDescription; } }
|
|
public override uint Signature { get { return 0x00494d41; } }
|
|
public override bool IsHierarchic { get { return false; } }
|
|
public override bool CanCreate { get { return true; } }
|
|
|
|
public AmiOpener ()
|
|
{
|
|
Extensions = new string[] { "ami", "amr" };
|
|
}
|
|
|
|
public override ArcFile TryOpen (ArcView file)
|
|
{
|
|
int count = file.View.ReadInt32 (4);
|
|
if (count <= 0)
|
|
return null;
|
|
uint base_offset = file.View.ReadUInt32 (8);
|
|
long max_offset = file.MaxOffset;
|
|
if (base_offset >= max_offset)
|
|
return null;
|
|
|
|
uint cur_offset = 16;
|
|
var dir = new List<Entry> (count);
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
if (cur_offset+16 > base_offset)
|
|
return null;
|
|
uint id = file.View.ReadUInt32 (cur_offset);
|
|
uint offset = file.View.ReadUInt32 (cur_offset+4);
|
|
uint size = file.View.ReadUInt32 (cur_offset+8);
|
|
uint packed_size = file.View.ReadUInt32 (cur_offset+12);
|
|
|
|
var entry = new AmiEntry (() => {
|
|
uint signature = file.View.ReadUInt32 (offset);
|
|
string ext, type;
|
|
if (0x00524353 == signature) {
|
|
ext = "scr"; type = "script";
|
|
} else if (0 != packed_size) {
|
|
ext = "grp"; type = "image";
|
|
} else {
|
|
ext = "dat"; type = "";
|
|
}
|
|
string name = string.Format ("{0:x8}.{1}", id, ext);
|
|
return new Tuple<string,string> (name, type);
|
|
});
|
|
|
|
entry.Offset = offset;
|
|
entry.UnpackedSize = size;
|
|
entry.IsPacked = 0 != packed_size;
|
|
entry.Size = entry.IsPacked ? packed_size : size;
|
|
if (!entry.CheckPlacement (max_offset))
|
|
return null;
|
|
dir.Add (entry);
|
|
cur_offset += 16;
|
|
}
|
|
return new ArcFile (file, this, dir);
|
|
}
|
|
|
|
public override Stream OpenEntry (ArcFile arc, Entry entry)
|
|
{
|
|
var input = arc.File.CreateStream (entry.Offset, entry.Size);
|
|
var packed_entry = entry as AmiEntry;
|
|
if (null == packed_entry || !packed_entry.IsPacked)
|
|
return input;
|
|
else
|
|
return new ZLibStream (input, CompressionMode.Decompress);
|
|
}
|
|
|
|
public override void Create (Stream output, IEnumerable<Entry> list, ResourceOptions options,
|
|
EntryCallback callback)
|
|
{
|
|
IDictionary<uint, PackedEntry> file_table = BuildFileTable (list);
|
|
uint file_count = (uint)file_table.Count;
|
|
if (0 == file_count)
|
|
throw new InvalidFormatException (arcStrings.AMINoFiles);
|
|
if (null != callback)
|
|
callback ((int)file_count+1, null, null);
|
|
|
|
int callback_count = 0;
|
|
long start_offset = output.Position;
|
|
uint data_offset = file_count * 16 + 16;
|
|
output.Seek (data_offset, SeekOrigin.Current);
|
|
foreach (var entry in file_table)
|
|
{
|
|
if (null != callback)
|
|
callback (callback_count++, entry.Value, arcStrings.MsgAddingFile);
|
|
long current_offset = output.Position;
|
|
if (current_offset > uint.MaxValue)
|
|
throw new FileSizeException();
|
|
entry.Value.Offset = (uint)current_offset;
|
|
entry.Value.Size = WriteAmiEntry (entry.Value, output);
|
|
}
|
|
if (null != callback)
|
|
callback (callback_count++, null, arcStrings.MsgWritingIndex);
|
|
output.Position = start_offset;
|
|
using (var header = new BinaryWriter (output, Encoding.ASCII, true))
|
|
{
|
|
header.Write (Signature);
|
|
header.Write (file_count);
|
|
header.Write (data_offset);
|
|
header.Write ((uint)0);
|
|
foreach (var entry in file_table)
|
|
{
|
|
header.Write (entry.Key);
|
|
header.Write ((uint)entry.Value.Offset);
|
|
header.Write ((uint)entry.Value.UnpackedSize);
|
|
header.Write ((uint)entry.Value.Size);
|
|
}
|
|
}
|
|
}
|
|
|
|
IDictionary<uint, PackedEntry> BuildFileTable (IEnumerable<Entry> list)
|
|
{
|
|
var table = new SortedDictionary<uint, PackedEntry>();
|
|
foreach (var entry in list)
|
|
{
|
|
string ext = Path.GetExtension (entry.Name).ToLower();
|
|
if (entry.Type != "image" && ext != ".scr")
|
|
continue;
|
|
uint id;
|
|
if (!uint.TryParse (Path.GetFileNameWithoutExtension (entry.Name), NumberStyles.HexNumber,
|
|
CultureInfo.InvariantCulture, out id))
|
|
continue;
|
|
PackedEntry existing;
|
|
if (table.TryGetValue (id, out existing))
|
|
{
|
|
var file_new = new FileInfo (entry.Name);
|
|
var file_old = new FileInfo (existing.Name);
|
|
if (file_new.LastWriteTime <= file_old.LastWriteTime)
|
|
continue;
|
|
}
|
|
table[id] = new PackedEntry
|
|
{
|
|
Name = entry.Name,
|
|
Type = entry.Type
|
|
};
|
|
}
|
|
return table;
|
|
}
|
|
|
|
uint WriteAmiEntry (PackedEntry entry, Stream output)
|
|
{
|
|
uint packed_size = 0;
|
|
using (var input = File.OpenRead (entry.Name))
|
|
{
|
|
long file_size = input.Length;
|
|
if (file_size > uint.MaxValue)
|
|
throw new FileSizeException();
|
|
entry.UnpackedSize = (uint)file_size;
|
|
if ("image" == entry.Type)
|
|
{
|
|
packed_size = WriteImageEntry (entry, input, output);
|
|
}
|
|
else
|
|
{
|
|
input.CopyTo (output);
|
|
}
|
|
}
|
|
return packed_size;
|
|
}
|
|
|
|
uint WriteImageEntry (PackedEntry entry, Stream input, Stream output)
|
|
{
|
|
var grp = FormatCatalog.Instance.LookupTag<GrpFormat> ("GRP").FirstOrDefault();
|
|
if (null == grp) // probably never happens
|
|
throw new FileFormatException ("GRP image encoder not available");
|
|
bool is_grp = grp.Signature == FormatCatalog.ReadSignature (input);
|
|
input.Position = 0;
|
|
using (var zstream = new ZLibStream (output, CompressionMode.Compress, true))
|
|
{
|
|
if (is_grp)
|
|
{
|
|
input.CopyTo (zstream);
|
|
}
|
|
else
|
|
{
|
|
var image = ImageFormat.Read (input);
|
|
if (null == image)
|
|
throw new InvalidFormatException (string.Format (arcStrings.MsgInvalidImageFormat, entry.Name));
|
|
grp.Write (zstream, image);
|
|
entry.UnpackedSize = (uint)zstream.TotalIn;
|
|
}
|
|
zstream.Flush();
|
|
return (uint)zstream.TotalOut;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Export(typeof(ImageFormat))]
|
|
public class GrpFormat : ImageFormat
|
|
{
|
|
public override string Tag { get { return "GRP"; } }
|
|
public override string Description { get { return Strings.arcStrings.GRPDescription; } }
|
|
public override uint Signature { get { return 0x00505247; } }
|
|
|
|
public override ImageMetaData ReadMetaData (Stream stream)
|
|
{
|
|
using (var file = new BinaryReader (stream, Encoding.ASCII, true))
|
|
{
|
|
if (file.ReadUInt32() != Signature)
|
|
return null;
|
|
var meta = new ImageMetaData();
|
|
meta.OffsetX = file.ReadInt16();
|
|
meta.OffsetY = file.ReadInt16();
|
|
meta.Width = file.ReadUInt16();
|
|
meta.Height = file.ReadUInt16();
|
|
meta.BPP = 32;
|
|
stream.Position = 0;
|
|
return meta;
|
|
}
|
|
}
|
|
|
|
public override ImageData Read (Stream file, ImageMetaData info)
|
|
{
|
|
int width = (int)info.Width;
|
|
int height = (int)info.Height;
|
|
int stride = width*4;
|
|
byte[] pixels = new byte[stride*height];
|
|
file.Position = 12;
|
|
for (int row = height-1; row >= 0; --row)
|
|
{
|
|
if (stride != file.Read (pixels, row*stride, stride))
|
|
throw new InvalidFormatException();
|
|
}
|
|
var bitmap = BitmapSource.Create (width, height, 96, 96,
|
|
PixelFormats.Bgra32, null, pixels, stride);
|
|
bitmap.Freeze();
|
|
|
|
return new ImageData (bitmap, info);
|
|
}
|
|
|
|
public override void Write (Stream stream, ImageData image)
|
|
{
|
|
using (var file = new BinaryWriter (stream, Encoding.ASCII, true))
|
|
{
|
|
file.Write (Signature);
|
|
file.Write ((short)image.OffsetX);
|
|
file.Write ((short)image.OffsetY);
|
|
file.Write ((ushort)image.Width);
|
|
file.Write ((ushort)image.Height);
|
|
|
|
var bitmap = image.Bitmap;
|
|
if (bitmap.Format != PixelFormats.Bgra32)
|
|
{
|
|
var converted_bitmap = new FormatConvertedBitmap();
|
|
converted_bitmap.BeginInit();
|
|
converted_bitmap.Source = image.Bitmap;
|
|
converted_bitmap.DestinationFormat = PixelFormats.Bgra32;
|
|
converted_bitmap.EndInit();
|
|
bitmap = converted_bitmap;
|
|
}
|
|
int stride = (int)image.Width * 4;
|
|
byte[] row_data = new byte[stride];
|
|
Int32Rect rect = new Int32Rect (0, (int)image.Height, (int)image.Width, 1);
|
|
for (uint row = 0; row < image.Height; ++row)
|
|
{
|
|
--rect.Y;
|
|
bitmap.CopyPixels (rect, row_data, stride, 0);
|
|
file.Write (row_data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class AmiScriptData : ScriptData
|
|
{
|
|
public uint Id;
|
|
public uint Type;
|
|
}
|
|
|
|
[Export(typeof(ScriptFormat))]
|
|
public class ScrFormat : ScriptFormat
|
|
{
|
|
public override string Tag { get { return "SCR"; } }
|
|
public override string Description { get { return Strings.arcStrings.SCRDescription; } }
|
|
public override uint Signature { get { return 0x00524353; } }
|
|
|
|
public override ScriptData Read (string name, Stream stream)
|
|
{
|
|
if (Signature != FormatCatalog.ReadSignature (stream))
|
|
return null;
|
|
uint script_id = Convert.ToUInt32 (name, 16);
|
|
uint max_offset = (uint)Math.Min (stream.Length, 0xffffffff);
|
|
|
|
using (var file = new BinaryReader (stream, Encodings.cp932, true))
|
|
{
|
|
uint script_type = file.ReadUInt32();
|
|
var script = new AmiScriptData {
|
|
Id = script_id,
|
|
Type = script_type
|
|
};
|
|
uint count = file.ReadUInt32();
|
|
for (uint i = 0; i < count; ++i)
|
|
{
|
|
uint offset = file.ReadUInt32();
|
|
if (offset >= max_offset)
|
|
throw new InvalidFormatException ("Invalid offset in script data file");
|
|
int size = file.ReadInt32();
|
|
uint id = file.ReadUInt32();
|
|
var header_pos = file.BaseStream.Position;
|
|
file.BaseStream.Position = offset;
|
|
byte[] line = file.ReadBytes (size);
|
|
if (line.Length != size)
|
|
throw new InvalidFormatException ("Premature end of file");
|
|
string text = Encodings.cp932.GetString (line);
|
|
|
|
script.TextLines.Add (new ScriptLine { Id = id, Text = text });
|
|
file.BaseStream.Position = header_pos;
|
|
}
|
|
return script;
|
|
}
|
|
}
|
|
|
|
public string GetName (ScriptData script_data)
|
|
{
|
|
var script = script_data as AmiScriptData;
|
|
if (null != script)
|
|
return script.Id.ToString ("x8");
|
|
else
|
|
return null;
|
|
}
|
|
|
|
struct IndexEntry
|
|
{
|
|
public uint offset, size, id;
|
|
}
|
|
|
|
public override void Write (Stream stream, ScriptData script_data)
|
|
{
|
|
var script = script_data as AmiScriptData;
|
|
if (null == script)
|
|
throw new ArgumentException ("Illegal ScriptData", "script_data");
|
|
using (var file = new BinaryWriter (stream, Encodings.cp932, true))
|
|
{
|
|
file.Write (Signature);
|
|
file.Write (script.Type);
|
|
uint count = (uint)script.TextLines.Count;
|
|
file.Write (count);
|
|
var index_pos = file.BaseStream.Position;
|
|
file.Seek ((int)count*12, SeekOrigin.Current);
|
|
var index = new IndexEntry[count];
|
|
int i = 0;
|
|
foreach (var line in script.TextLines)
|
|
{
|
|
var text = Encodings.cp932.GetBytes (line.Text);
|
|
index[i].offset = (uint)file.BaseStream.Position;
|
|
index[i].size = (uint)text.Length;
|
|
index[i].id = line.Id;
|
|
file.Write (text);
|
|
file.Write ((byte)0);
|
|
++i;
|
|
}
|
|
var end_pos = file.BaseStream.Position;
|
|
file.BaseStream.Position = index_pos;
|
|
foreach (var entry in index)
|
|
{
|
|
file.Write (entry.offset);
|
|
file.Write (entry.size);
|
|
file.Write (entry.id);
|
|
}
|
|
file.BaseStream.Position = end_pos;
|
|
}
|
|
}
|
|
}
|
|
}
|