mirror of
https://github.com/crskycode/GARbro.git
synced 2024-11-27 07:34:00 +08:00
205 lines
6.9 KiB
C#
205 lines
6.9 KiB
C#
//! \file ImagePDT.cs
|
|
//! \date 2023 Oct 13
|
|
//! \brief AyPio 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 System.ComponentModel.Composition;
|
|
using System.IO;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
|
|
// [960726][AyPio] Chuushaki
|
|
// [970314][AyPio] Stars
|
|
|
|
namespace GameRes.Formats.AyPio
|
|
{
|
|
internal class PdtMetaData : ImageMetaData
|
|
{
|
|
public byte Rle1;
|
|
public byte Rle2;
|
|
}
|
|
|
|
[Export(typeof(ImageFormat))]
|
|
public class PdtFormat : ImageFormat
|
|
{
|
|
public override string Tag => "PDT/UK2";
|
|
public override string Description => "UK2 engine image format";
|
|
public override uint Signature => 0;
|
|
|
|
public PdtFormat ()
|
|
{
|
|
Extensions = new[] { "pdt", "anm" };
|
|
}
|
|
|
|
public override ImageMetaData ReadMetaData (IBinaryStream file)
|
|
{
|
|
if (file.ReadByte() != 0x34)
|
|
return null;
|
|
file.Position = 0x21;
|
|
byte rle1 = file.ReadUInt8();
|
|
byte rle2 = file.ReadUInt8();
|
|
int left = file.ReadUInt16();
|
|
int top = file.ReadUInt16();
|
|
int right = file.ReadUInt16();
|
|
int bottom = file.ReadUInt16();
|
|
int width = (right - left + 1) << 3;
|
|
int height = (((bottom - top) >> 1) + 1) << 1;
|
|
if (width <= 0 || height <= 0 || width > 2048 || height > 512)
|
|
return null;
|
|
return new PdtMetaData {
|
|
Width = (uint)width,
|
|
Height = (uint)height,
|
|
OffsetX = left << 3,
|
|
OffsetY = top,
|
|
BPP = 4,
|
|
Rle1 = rle1,
|
|
Rle2 = rle2,
|
|
};
|
|
}
|
|
|
|
public override ImageData Read (IBinaryStream file, ImageMetaData info)
|
|
{
|
|
var reader = new Pdt4Reader (file, (PdtMetaData)info);
|
|
return reader.Unpack();
|
|
}
|
|
|
|
public override void Write (Stream file, ImageData image)
|
|
{
|
|
throw new System.NotImplementedException ("PdtFormat.Write not implemented");
|
|
}
|
|
}
|
|
|
|
internal class Pdt4Reader
|
|
{
|
|
IBinaryStream m_input;
|
|
PdtMetaData m_info;
|
|
|
|
public Pdt4Reader (IBinaryStream input, PdtMetaData info)
|
|
{
|
|
m_input = input;
|
|
m_info = info;
|
|
}
|
|
|
|
int m_stride;
|
|
int m_rows;
|
|
|
|
public ImageData Unpack ()
|
|
{
|
|
m_input.Position = 1;
|
|
var palette = ReadPalette();
|
|
m_input.Position = 0x2B;
|
|
int output_stride = m_info.iWidth >> 1;
|
|
int height = m_info.iHeight;
|
|
m_stride = m_info.iWidth >> 3;
|
|
m_rows = height >> 1;
|
|
int plane_size = m_stride * height;
|
|
var planes = new byte[][] {
|
|
new byte[plane_size], new byte[plane_size], new byte[plane_size], new byte[plane_size]
|
|
};
|
|
for (int i = 0; i < 4; ++i)
|
|
UnpackPlane (planes[i]);
|
|
var pixels = new byte[output_stride * height];
|
|
FlattenPlanes (planes, pixels);
|
|
return ImageData.Create (m_info, PixelFormats.Indexed4, palette, pixels, output_stride);
|
|
}
|
|
|
|
void UnpackPlane (byte[] output)
|
|
{
|
|
for (int x = 0; x < m_stride; ++x)
|
|
{
|
|
int dst = x;
|
|
int y = 0;
|
|
while (y < m_rows)
|
|
{
|
|
int count = 1;
|
|
byte p0, p1;
|
|
byte ctl = m_input.ReadUInt8();
|
|
if (ctl == m_info.Rle1)
|
|
{
|
|
count = m_input.ReadUInt8();
|
|
p0 = m_input.ReadUInt8();
|
|
p1 = m_input.ReadUInt8();
|
|
}
|
|
else if (ctl == m_info.Rle2)
|
|
{
|
|
count = m_input.ReadUInt8();
|
|
p1 = p0 = m_input.ReadUInt8();
|
|
}
|
|
else
|
|
{
|
|
p0 = ctl;
|
|
p1 = m_input.ReadUInt8();
|
|
}
|
|
while (count --> 0)
|
|
{
|
|
output[dst] = p0;
|
|
dst += m_stride;
|
|
output[dst] = p1;
|
|
dst += m_stride;
|
|
++y;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FlattenPlanes (byte[][] planes, byte[] output)
|
|
{
|
|
int plane_size = planes[0].Length;
|
|
int dst = 0;
|
|
for (int src = 0; src < plane_size; ++src)
|
|
{
|
|
int b0 = planes[0][src];
|
|
int b1 = planes[1][src];
|
|
int b2 = planes[2][src];
|
|
int b3 = planes[3][src];
|
|
for (int j = 0; j < 8; j += 2)
|
|
{
|
|
byte px = (byte)((((b0 << j) & 0x80) >> 3)
|
|
| (((b1 << j) & 0x80) >> 2)
|
|
| (((b2 << j) & 0x80) >> 1)
|
|
| (((b3 << j) & 0x80) ));
|
|
px |= (byte)((((b0 << j) & 0x40) >> 6)
|
|
| (((b1 << j) & 0x40) >> 5)
|
|
| (((b2 << j) & 0x40) >> 4)
|
|
| (((b3 << j) & 0x40) >> 3));
|
|
output[dst++] = px;
|
|
}
|
|
}
|
|
}
|
|
|
|
BitmapPalette ReadPalette ()
|
|
{
|
|
var colors = new Color[16];
|
|
for (int i = 0; i < 16; ++i)
|
|
{
|
|
ushort rgb = m_input.ReadUInt16();
|
|
int b = (rgb & 0xF) * 0x11;
|
|
int r = ((rgb >> 4) & 0xF) * 0x11;
|
|
int g = ((rgb >> 8) & 0xF) * 0x11;
|
|
colors[i] = Color.FromRgb ((byte)r, (byte)g, (byte)b);
|
|
}
|
|
return new BitmapPalette (colors);
|
|
}
|
|
}
|
|
}
|