updated formats.

(PICT): fixed 16bpp images.
(GDT): added image format.
(DXR): tweaks to recognizing DXR inside exe files.
(NSA): recognize mp3 files named as nsa.
(TLZ): added ContainedFormats.
(WrapSingleFileAchive): class that represents single file as an archive.
(DesertCgOPener): Software House Parsley archive.
(Triangle.RleReader): utilize UnpackV2, replaced BinaryReader with IBinaryStream.

ArcFormats/ArcFormats.csproj

@@ -106,6 +106,7 @@
     <Compile Include="AdvSys\ImageGWD.cs" />
     <Compile Include="Ail\ArcLNK2.cs" />
     <Compile Include="AIRNovel\ArcAIR.cs" />
+    <Compile Include="CsWare\ImageGDT.cs" />
     <Compile Include="FC01\ArcBDT.cs" />
     <Compile Include="FC01\BdtTables.cs" />
     <Compile Include="GScripter\ArcDATA.cs" />
@@ -153,6 +154,8 @@
     <Compile Include="NScripter\Script.cs" />
     <Compile Include="Psp\ArcQPK.cs" />
     <Compile Include="ScrPlayer\ImageIMG.cs" />
+    <Compile Include="SingleFileArchive.cs" />
+    <Compile Include="Software House Parsley\ArcCG3.cs" />
     <Compile Include="Software House Parsley\ArcScn.cs" />
     <Compile Include="TechGian\ArcBIN.cs" />
     <Compile Include="Unity\ScriptDSM.cs" />

ArcFormats/CsWare/ImageGDT.cs

@@ -0,0 +1,569 @@
+//! \file       ImageGDT.cs
+//! \date       2023 Sep 29
+//! \brief      AGS 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;
+using System.Windows.Media.Imaging;
+
+namespace GameRes.Formats.CsWare
+{
+    internal class GdtMetaData : ImageMetaData
+    {
+        public  byte    Flags;
+
+        public bool HasPalette => (Flags & 0x80) != 0;
+        public bool   IsDouble => (Flags & 0x40) == 0;
+    }
+
+    [Export(typeof(ImageFormat))]
+    public class GdtFormat : ImageFormat
+    {
+        public override string         Tag => "GDT";
+        public override string Description => "AGS engine image format";
+        public override uint     Signature => 0x314144; // 'DA1'
+
+        public override ImageMetaData ReadMetaData (IBinaryStream file)
+        {
+            var header = file.ReadHeader (16);
+            var info = new GdtMetaData {
+                OffsetX = header[8] << 3,
+                OffsetY = header.ToUInt16 (0xA),
+                Width   = (uint)header[9] << 3,
+                Height  = header.ToUInt16 (0xC),
+                BPP     = 4,
+                Flags   = header[0xF],
+            };
+            return info;
+        }
+
+        public override ImageData Read (IBinaryStream file, ImageMetaData info)
+        {
+            var reader = new GdtReader (file, (GdtMetaData)info);
+            return reader.Unpack();
+        }
+
+        public override void Write (Stream file, ImageData image)
+        {
+            throw new System.NotImplementedException ("GdtFormat.Write not implemented");
+        }
+    }
+
+    internal class GdtReader
+    {
+        IBinaryStream   m_input;
+        GdtMetaData     m_info;
+        int             m_stride;
+        int             m_output_stride;
+
+        public BitmapPalette Palette { get; private set; }
+
+        public GdtReader (IBinaryStream file, GdtMetaData info)
+        {
+            m_input = file;
+            m_info = info;
+            m_stride = info.iWidth >> 3;
+            m_output_stride = info.iWidth >> 1;
+        }
+
+        byte[][]    m_planes;
+
+        public ImageData Unpack ()
+        {
+            m_input.Position = 0x10;
+            if (m_info.HasPalette)
+            {
+                Palette = ReadPalette();
+            }
+            var packed_sizes = new ushort[4];
+            for (int i = 0; i < 4; ++i)
+                packed_sizes[i] = m_input.ReadUInt16();
+            long plane_pos = m_input.Position;
+            int plane_size = m_stride * m_info.iHeight;
+            m_planes = new byte[][] {
+                new byte[plane_size], new byte[plane_size], new byte[plane_size], new byte[plane_size],
+            };
+            Action<int> UnpackPlane = UnpackSingle;
+            if (m_info.IsDouble)
+                UnpackPlane = UnpackDouble;
+            for (int i = 0; i < 4; ++i)
+            {
+                m_input.Position = plane_pos;
+                plane_pos += packed_sizes[i];
+                UnpackPlane (i);
+            }
+            var pixels = new byte[m_output_stride * m_info.iHeight];
+            FlattenPlanes (pixels);
+            PixelFormat format;
+            if (null == Palette)
+                format = PixelFormats.Gray4;
+            else
+                format = PixelFormats.Indexed4;
+            return ImageData.Create (m_info, format, Palette, pixels, m_output_stride);
+        }
+
+        void UnpackSingle (int plane_index)
+        {
+            int h = m_info.iHeight;
+            int w = m_stride;
+            int dst = 0;
+            while (w --> 0)
+            {
+                Unpack8Line (plane_index, dst);
+                dst += h;
+            }
+        }
+
+        void UnpackDouble (int plane_index)
+        {
+            var output = m_planes[plane_index];
+            int h = m_info.iHeight;
+            int width = m_stride;
+            int dst = 0;
+            if ((m_info.OffsetX & 8) != 0)
+            {
+                Unpack8Line (plane_index, dst);
+                --width;
+                dst += h;
+            }
+            if ((m_input.Position & 1) != 0)
+                m_input.Seek (1, SeekOrigin.Current);
+            if (1 == width)
+            {
+                Unpack8Line (plane_index, dst);
+                return;
+            }
+            while (m_input.PeekByte() != -1)
+            {
+                byte op  = m_input.ReadUInt8();
+                byte ctl = m_input.ReadUInt8();
+                if (ctl < 0x80)
+                {
+                    if (0 == ctl)
+                        continue;
+                    ushort w = (ushort)(((op & 0xF) << 8 | (op & 0xF0) >> 4) * 0x11);
+                    int count = ctl;
+                    Fill (output, dst  , count, w);
+                    Fill (output, dst+h, count, w);
+                    dst += count * 2;
+                }
+                else if (ctl < 0xC0)
+                {
+                    int count = ctl & 0x3F;
+                    int w = op & 0xF | (op & 0xF0) << 4;
+                    uint d = (uint)(w | (w & 0x0303) << 18 | (w & 0x0C0C) << 14);
+                    d = Binary.BigEndian (d | d << 4);
+                    Fill (output, dst  , count, d);
+                    Fill (output, dst+h, count, d);
+                    dst += count * 4;
+                }
+                else if (ctl < 0xD0)
+                {
+                    byte b = (byte)((ctl & 0xF) | ctl << 4);
+                    int count = op;
+                    Fill (output, dst  , count, b);
+                    Fill (output, dst+h, count, b);
+                    dst += count;
+                }
+                else if (ctl < 0xD2)
+                {
+                    int count = (ctl & 1) << 8 | op;
+                    while (count --> 0)
+                    {
+                        output[dst  ] = m_input.ReadUInt8();
+                        output[dst+h] = m_input.ReadUInt8();
+                    }
+                }
+                else if (0xD2 == ctl)
+                {
+                    dst += op;
+                }
+                else if (ctl < 0xF3)
+                {
+                    int count = op;
+                    int off = 0;
+                    switch (ctl)
+                    {
+                    case 0xD3: off = 16; break;
+                    case 0xD4: off = 12; break;
+                    case 0xD5: off = 8; break;
+                    case 0xD6: off = 4; break;
+                    case 0xD7: off = 2; break;
+                    case 0xD8: off = 1; break;
+                    case 0xD9: off = h * 2 + 8; break;
+                    case 0xDA: off = h * 2 + 4; break;
+                    case 0xDB: off = h * 2 + 2; break;
+                    case 0xDC: off = h * 2 + 1; break;
+                    case 0xDD: off = h * 2; break;
+                    case 0xDE: off = h * 2 - 1; break;
+                    case 0xDF: off = h * 2 - 2; break;
+                    case 0xE0: off = h * 2 - 4; break;
+                    case 0xE1: off = h * 2 - 8; break;
+                    case 0xE2: off = h * 4 + 8; break;
+                    case 0xE3: off = h * 4 + 4; break;
+                    case 0xE4: off = h * 4 + 2; break;
+                    case 0xE5: off = h * 4 + 1; break;
+                    case 0xE6: off = h * 4; break;
+                    case 0xE7: off = h * 4 - 1; break;
+                    case 0xE8: off = h * 4 - 2; break;
+                    case 0xE9: off = h * 4 - 4; break;
+                    case 0xEA: off = h * 4 - 8; break;
+                    case 0xEB: off = h * 6 + 4; break;
+                    case 0xEC: off = h * 6 + 2; break;
+                    case 0xED: off = h * 6 + 1; break;
+                    case 0xEE: off = h * 6; break;
+                    case 0xEF: off = h * 6 - 1; break;
+                    case 0xF0: off = h * 6 - 2; break;
+                    case 0xF1: off = h * 6 - 4; break;
+                    case 0xF2: off = h * 8; break;
+                    }
+                    Binary.CopyOverlapped (output, dst-off, dst, count);
+                    Binary.CopyOverlapped (output, dst-off+h, dst+h, count);
+                    dst += count;
+                }
+                else if (ctl < 0xFC)
+                {
+                    int count = op;
+                    var source = m_planes[(ctl - 0xF3) % 3];
+                    if (ctl < 0xF6)
+                    {
+                        Buffer.BlockCopy (source, dst, output, dst, count);
+                        Buffer.BlockCopy (source, dst+h, output, dst+h, count);
+                        dst += count;
+                    }
+                    else if (ctl > 0xF8)
+                    {
+                        var source1 = m_planes[ctl & 1];
+                        var source2 = m_planes[ctl & 2];
+                        while (count --> 0)
+                        {
+                            output[dst] = (byte)(source1[dst] & source2[dst]);
+                            output[dst+h] = (byte)(source1[dst+h] & source2[dst+h]);
+                            ++dst;
+                        }
+                    }
+                    else
+                    {
+                        while (count --> 0)
+                        {
+                            output[dst] = (byte)~source[dst];
+                            output[dst+h] = (byte)~source[dst+h];
+                            ++dst;
+                        }
+                    }
+                }
+                else if (0xFC == ctl)
+                {
+                    int count = op;
+                    byte b = m_input.ReadUInt8();
+                    Fill (output, dst  , count, b);
+                    Fill (output, dst+h, count, b);
+                    dst += count;
+                }
+                else if (0xFD == ctl)
+                {
+                    if (op < 0x80)
+                    {
+                        int count = op;
+                        ushort w = m_input.ReadUInt16();
+                        Fill (output, dst  , count, w);
+                        Fill (output, dst+h, count, w);
+                        dst += count * 2;
+                    }
+                    else
+                    {
+                        int count = op & 0x7F;
+                        ushort w1 = m_input.ReadUInt16();
+                        ushort w2 = m_input.ReadUInt16();
+                        Fill (output, dst  , count, (ushort)(w1 << 8   | w2 & 0xFF));
+                        Fill (output, dst+h, count, (ushort)(w1 & 0xFF | w2 >> 8));
+                        dst += count * 2;
+                    }
+                }
+                else if (0xFE == ctl)
+                {
+                    int count = op & 0x3F;
+                    if (op < 0x80)
+                    {
+                        byte b0 = m_input.ReadUInt8();
+                        byte b1 = m_input.ReadUInt8();
+                        int d = b1 | b0 << 16;
+                        d = d & 0x0F000F | (d & 0xF000F0) << 4;
+                        d *= 0x11;
+                        d = Binary.BigEndian (d);
+                        Fill (output, dst  , count, (uint)d);
+                        Fill (output, dst+h, count, (uint)d);
+                    }
+                    else
+                    {
+                        uint d0 = m_input.ReadUInt32();
+                        uint d1 = m_input.ReadUInt32();
+                        uint p0 = d0 << 24 | d0 & 0xFF0000 | (d1 & 0xFF) << 8 | (d1 & 0xFF0000) >> 16;
+                        uint p1 = (d0 & 0xFF00) << 16 | (d0 & 0xFF000000) >> 8 | d1 & 0xFF00 | (d1 & 0xFF000000) >> 24;
+                        Fill (output, dst  , count, p0);
+                        Fill (output, dst+h, count, p1);
+                    }
+                    dst += count * 4;
+                }
+                else // 0xFF
+                {
+                    dst += h;
+                    width -= 2;
+                    if (0 == width)
+                        break;
+                    if (1 == width)
+                    {
+                        Unpack8Line (plane_index, dst);
+                        break;
+                    }
+                }
+            }
+        }
+
+        void Unpack8Line (int plane_index, int dst)
+        {
+            var output = m_planes[plane_index];
+            int h = m_info.iHeight;
+            int end_pos = dst + h;
+            while (m_input.PeekByte() != -1)
+            {
+                byte ctl = m_input.ReadUInt8();
+                if (ctl < 0x40)
+                {
+                    byte b = 0;
+                    if (ctl >= 0x20)
+                        b = 0xFF;
+                    int count = ctl & 0x1F;
+                    if (0 == count)
+                        count = m_input.ReadUInt8();
+                    Fill (output, dst, count, b);
+                    dst += count;
+                }
+                else if (ctl < 0xA0)
+                {
+                    int count = ctl & 0x1F;
+                    if (0 == count)
+                        count = m_input.ReadUInt8();
+                    int src_plane = (ctl - 0x40) >> 5;
+                    Buffer.BlockCopy (m_planes[src_plane], dst, output, dst, count);
+                    dst += count;
+                }
+                else if (ctl < 0xF0)
+                {
+                    int count = ctl & 0xF;
+                    if (0 == count)
+                        count = m_input.ReadUInt8();
+                    switch (ctl & 0xF0)
+                    {
+                    case 0xA0: Binary.CopyOverlapped (output, dst-16, dst, count); break;
+                    case 0xB0: Binary.CopyOverlapped (output, dst-8, dst, count); break;
+                    case 0xC0: Binary.CopyOverlapped (output, dst-4, dst, count); break;
+                    case 0xD0: Binary.CopyOverlapped (output, dst-2, dst, count); break;
+                    case 0xE0: Binary.CopyOverlapped (output, dst-h*2, dst, count); break;
+                    }
+                    dst += count;
+                }
+                else if (ctl < 0xF9)
+                {
+                    int count = ctl & 0xF;
+                    if (0 == count)
+                        count = m_input.ReadUInt8();
+                    m_input.Read (output, dst, count);
+                    dst += count;
+                }
+                else if (0xF9 == ctl)
+                {
+                    dst += m_input.ReadUInt8();
+                }
+                else if (0xFA == ctl)
+                {
+                    int count = m_input.ReadUInt8();
+                    byte b = m_input.ReadUInt8();
+                    Fill (output, dst, count, b);
+                    dst += count;
+                }
+                else if (0xFB == ctl)
+                {
+                    int count = m_input.ReadUInt8();
+                    int b = count >> 7;
+                    count &= 0x7F;
+                    while (count --> 0)
+                    {
+                        output[dst] = (byte)~m_planes[b][dst];
+                        ++dst;
+                    }
+                }
+                else if (0xFC == ctl)
+                {
+                    int count = m_input.ReadUInt8();
+                    if ((count & 0x80) != 0)
+                    {
+                        count &= 0x7F;
+                        byte b = m_input.ReadUInt8();
+                        ushort d = (ushort)(b & 0xF | (b & 0xF0) << 4);
+                        d |= (ushort)(d << 4);
+                        Fill (output, dst, count, d);
+                        dst += count * 2;
+                    }
+                    else
+                    {
+                        while (count --> 0)
+                        {
+                            output[dst] = (byte)~m_planes[2][dst];
+                            ++dst;
+                        }
+                    }
+                }
+                else if (0xFD == ctl)
+                {
+                    int count = m_input.ReadUInt8();
+                    if ((count & 0x80) != 0)
+                    {
+                        byte b = m_input.ReadUInt8();
+                        uint d = (uint)(b & 0xF | b << 4 | (b & 0xF0) << 8);
+                        if ((count & 0x40) != 0)
+                        {
+                            b = m_input.ReadUInt8();
+                            d |= (uint)((b & 0xF) << 16 | b << 20 | (b & 0xF0) << 24);
+                        }
+                        else
+                        {
+                            d |= (d & 0x3F3F) << 18 | (d & 0xC0C0) << 10;
+                        }
+                        count &= 0x3F;
+                        Fill (output, dst, count, d);
+                        dst += count * 4;
+                    }
+                    else
+                    {
+                        ushort w = m_input.ReadUInt16();
+                        Fill (output, dst, count, w);
+                        dst += count * 2;
+                    }
+                }
+                else if (0xFE == ctl)
+                {
+                    int count = m_input.ReadUInt8();
+                    int b = count & 0xC0;
+                    if (b != 0)
+                    {
+                        count &= 0x3F;
+                        b >>= 6;
+                        while (count --> 0)
+                        {
+                            output[dst] = (byte)(m_planes[b & 1][dst] & m_planes[b & 2][dst]);
+                            ++dst;
+                        }
+                    }
+                    else
+                    {
+                        uint u = m_input.ReadUInt32();
+                        Fill (output, dst, count, u);
+                        dst += count * 4;
+                    }
+                }
+                else // 0xFF
+                {
+                    break;
+                }
+            }
+        }
+
+        void FlattenPlanes (byte[] output)
+        {
+            int plane_size = m_planes[0].Length;
+            int src = 0;
+            for (int x = 0; x < m_output_stride; x += 4)
+            {
+                int dst = x;
+                for (int y = 0; y < m_info.iHeight; ++y)
+                {
+                    byte b0 = m_planes[0][src];
+                    byte b1 = m_planes[1][src];
+                    byte b2 = m_planes[2][src];
+                    byte b3 = m_planes[3][src];
+                    ++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) >> 0));
+                        px |= (byte)((((b0 << j) & 0x40) >> 6)
+                                   | (((b1 << j) & 0x40) >> 5)
+                                   | (((b2 << j) & 0x40) >> 4)
+                                   | (((b3 << j) & 0x40) >> 3));
+                        output[dst+j/2] = px;
+                    }
+                    dst += m_output_stride;
+                }
+            }
+        }
+
+        static void Fill (byte[] output, int dst, int count, byte pixel)
+        {
+            while (count --> 0)
+            {
+                output[dst++] = pixel;
+            }
+        }
+
+        static void Fill (byte[] output, int dst, int count, ushort pixel)
+        {
+            count <<= 1;
+            for (int i = 0; i < count; i += 2)
+            {
+                LittleEndian.Pack (pixel, output, dst+i);
+            }
+        }
+
+        static void Fill (byte[] output, int dst, int count, uint pixel)
+        {
+            count <<= 2;
+            for (int i = 0; i < count; i += 4)
+            {
+                LittleEndian.Pack (pixel, output, dst+i);
+            }
+        }
+
+        BitmapPalette ReadPalette ()
+        {
+            using (var bits = new MsbBitStream (m_input.AsStream, true))
+            {
+                var colors = new Color[16];
+                for (int i = 0; i < 16; ++i)
+                {
+                    int b = bits.GetBits (4) * 0x11;
+                    int r = bits.GetBits (4) * 0x11;
+                    int g = bits.GetBits (4) * 0x11;
+                    colors[i] = Color.FromRgb ((byte)r, (byte)g, (byte)b);
+                }
+                return new BitmapPalette (colors);
+            }
+        }
+    }
+}

ArcFormats/Lilim/ArcAOS.cs

@@ -60,6 +60,7 @@ namespace GameRes.Formats.Lilim
             if (!name_buf.SequenceEqual (IndexLink) && !name_buf.SequenceEqual (IndexEnd))
                 return null;
 
+            string last_name = null;
             long current_offset = 0;
             var dir = new List<Entry> (0x3E);
             while (current_offset < file.MaxOffset)
@@ -79,6 +80,9 @@ namespace GameRes.Formats.Lilim
                     if (-1 == name_length)
                         name_length = name_buf.Length;
                     var name = Encodings.cp932.GetString (name_buf, 0, name_length);
+                    if (last_name == name || string.IsNullOrWhiteSpace (name))
+                        return null;
+                    last_name = name;
                     var entry = FormatCatalog.Instance.Create<PackedEntry> (name);
                     entry.Offset = file.View.ReadUInt32 (current_offset+0x10);
                     entry.Size   = file.View.ReadUInt32 (current_offset+0x14);

ArcFormats/Macintosh/ImagePICT.cs

@@ -294,8 +294,10 @@ namespace GameRes.Formats.Apple
         byte[] RepackPixels (Pixmap pixmap)
         {
             int bpp = m_info.BPP;
-            if (bpp <= 16)
+            if (bpp < 16)
                 return m_buffer;
+            else if (16 == bpp)
+                return Repack16bpp();
             int bytes_per_pixel = bpp / 8;
             int stride = m_info.iWidth * bytes_per_pixel;
             var pixels = new byte[stride * m_info.iHeight];
@@ -326,6 +328,17 @@ namespace GameRes.Formats.Apple
             return pixels;
         }
 
+        byte[] Repack16bpp () // swap 16bit pixels to little-endian order
+        {
+            for (int p = 1; p < m_buffer.Length; p += 2)
+            {
+                byte b = m_buffer[p-1];
+                m_buffer[p-1] = m_buffer[p];
+                m_buffer[p] = b;
+            }
+            return m_buffer;
+        }
+
         void SetFormat (Pixmap pixmap)
         {
             int bpp = null == pixmap ? 8 : pixmap.BPP;

ArcFormats/Macromedia/ArcDXR.cs

@@ -49,7 +49,7 @@ namespace GameRes.Formats.Macromedia
 
         public DxrOpener ()
         {
-            Extensions = new[] { "dxr", "cxt", "cct", "dcr", "exe" };
+            Extensions = new[] { "dxr", "cxt", "cct", "dcr", "dir", "exe" };
             Signatures = new[] { SignatureXFIR, SignatureRIFX, 0x00905A4Du, 0u };
         }
 
@@ -411,7 +411,7 @@ namespace GameRes.Formats.Macromedia
                 pos = exe.Overlay.Offset;
                 if (pos >= file.MaxOffset)
                     return 0;
-                if (file.View.AsciiEqual (pos, "10JP"))
+                if (file.View.AsciiEqual (pos, "10JP") || file.View.AsciiEqual (pos, "59JP"))
                 {
                     pos = file.View.ReadUInt32 (pos+4);
                 }
@@ -436,7 +436,8 @@ namespace GameRes.Formats.Macromedia
                     // only the first XFIR entry is matched here, but archive may contain multiple sub-archives.
                     if (entry.FourCC == "File")
                     {
-                        if (file.View.AsciiEqual (entry.Offset-8, "XFIR"))
+                        if (file.View.AsciiEqual (entry.Offset-8, "XFIR")
+                            && !file.View.AsciiEqual (entry.Offset, "artX"))
                             return entry.Offset-8;
                     }
                 }
@@ -469,6 +470,8 @@ namespace GameRes.Formats.Macromedia
                 Left   = reader.ReadI16();
                 Bottom = reader.ReadI16();
                 Right  = reader.ReadI16();
+                if (data.Length > 0x16)
+                {
                     reader.Skip (0x0C);
                     BitDepth = reader.ReadU16() & 0xFF; // ???
                     if (data.Length >= 0x1C)
@@ -479,6 +482,7 @@ namespace GameRes.Formats.Macromedia
                 }
             }
         }
+    }
 
     internal class SoundEntry : PackedEntry
     {

ArcFormats/NScripter/ArcNSA.cs

@@ -107,6 +107,9 @@ namespace GameRes.Formats.NScripter
             catch { /* ignore parse errors */ }
             if (zero_signature || !file.Name.HasExtension (".nsa"))
                 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");
 
             var password = QueryPassword();
             if (string.IsNullOrEmpty (password))

ArcFormats/Otemoto/ArcTLZ.cs

@@ -39,6 +39,11 @@ namespace GameRes.Formats.Otemoto
         public override bool  IsHierarchic { get { return false; } }
         public override bool      CanWrite { get { return false; } }
 
+        public TlzOpener ()
+        {
+            ContainedFormats = new[] { "BMP", "SCR" };
+        }
+
         public override ArcFile TryOpen (ArcView file)
         {
             int count = file.View.ReadInt32 (0xC);
@@ -61,7 +66,7 @@ namespace GameRes.Formats.Otemoto
                 if (0 == name_length || name_length > 0x100)
                     return null;
                 entry.Name = file.View.ReadString (index_offset+0x10, name_length);
-                entry.Type = FormatCatalog.Instance.GetTypeFromName (entry.Name);
+                entry.Type = FormatCatalog.Instance.GetTypeFromName (entry.Name, ContainedFormats);
                 entry.IsPacked = entry.UnpackedSize != entry.Size;
                 dir.Add (entry);
                 index_offset += 0x10 + name_length;
@@ -78,4 +83,9 @@ namespace GameRes.Formats.Otemoto
             return new LzssStream (input);
         }
     }
+
+    [Export(typeof(ResourceAlias))]
+    [ExportMetadata("Extension", "SNR")]
+    [ExportMetadata("Target", "SCR")]
+    internal class SnrFormat : ResourceAlias { }
 }

ArcFormats/Otemoto/ImageMAG.cs

@@ -45,7 +45,7 @@ namespace GameRes.Formats.Otemoto
     [Export(typeof(ImageFormat))]
     public class MagFormat : ImageFormat
     {
-        public override string         Tag { get { return "MAG"; } }
+        public override string         Tag { get { return "MAG/MAKI02"; } }
         public override string Description { get { return "Otemoto image format"; } }
         public override uint     Signature { get { return 0x494B414D; } } // 'MAKI02'
 

ArcFormats/SingleFileArchive.cs

@@ -0,0 +1,67 @@
+//! \file       SingleFileArchive.cs
+//! \date       2023 Oct 05
+//! \brief      represent single file as an archive for convenience.
+//
+// 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.Collections.Generic;
+
+namespace GameRes.Formats
+{
+    public class WrapSingleFileArchive : ArcFile
+    {
+        internal static readonly ArchiveFormat Format = new SingleFileArchiveFormat();
+
+        public WrapSingleFileArchive (ArcView file, Entry entry)
+            : base (file, Format, new List<Entry> { entry })
+        {
+        }
+
+        public WrapSingleFileArchive (ArcView file, string entry_name)
+            : base (file, Format, new List<Entry> { CreateEntry (file, entry_name) })
+        {
+        }
+
+        private static Entry CreateEntry (ArcView file, string name)
+        {
+            var entry = FormatCatalog.Instance.Create<Entry> (name);
+            entry.Offset = 0;
+            entry.Size = (uint)file.MaxOffset;
+            return entry;
+        }
+
+        /// this format is not registered in catalog and only accessible via WrapSingleFileArchive.Format singleton.
+        private class SingleFileArchiveFormat : ArchiveFormat
+        {
+            public override string         Tag => "DAT/BOGUS";
+            public override string Description => "Not an archive";
+            public override uint     Signature => 0;
+            public override bool  IsHierarchic => false;
+            public override bool      CanWrite => false;
+
+            public override ArcFile TryOpen (ArcView file)
+            {
+                return new WrapSingleFileArchive (file, System.IO.Path.GetFileName (file.Name));
+            }
+        }
+    }
+}

ArcFormats/Software House Parsley/ArcCG3.cs

@@ -0,0 +1,170 @@
+//! \file       ArcCG3.cs
+//! \date       2023 Oct 10
+//! \brief      Software House Parsley CG archive.
+//
+// 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;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Windows.Media;
+
+// [050610][Software House Parsley] Desert Time Mugen no Meikyuu PE
+
+namespace GameRes.Formats.Parsley
+{
+    [Export(typeof(ArchiveFormat))]
+    public class DesertCgOpener : ArchiveFormat
+    {
+        public override string         Tag { get { return "CG/DESERT"; } }
+        public override string Description { get { return "Software House Parsley CG archive"; } }
+        public override uint     Signature { get { return 0; } }
+        public override bool  IsHierarchic { get { return false; } }
+        public override bool      CanWrite { get { return false; } }
+
+        public DesertCgOpener ()
+        {
+            Extensions = new string[] { "" };
+        }
+
+        public override ArcFile TryOpen (ArcView file)
+        {
+            if (!VFS.IsPathEqualsToFileName (file.Name, "CG"))
+                return null;
+            int count = file.View.ReadInt32 (0);
+            if (!IsSaneCount (count))
+                return null;
+            uint index_pos = 4;
+            var filename_table = LookupFileNameTable (file, count);
+            Func<int, string> get_entry_name;
+            if (filename_table != null)
+                get_entry_name = n => filename_table[n];
+            else
+                get_entry_name = n => string.Format ("CG#{0:D4}");
+            long last_offset = count * 4 + 4;
+            var dir = new List<Entry> (count);
+            for (int i = 0; i < count; ++ i)
+            {
+                uint offset = file.View.ReadUInt32 (index_pos);
+                if (0 == offset)
+                    break;
+                if (offset <= last_offset || offset >= file.MaxOffset)
+                    return null;
+                var entry = new Entry {
+                    Name = get_entry_name (i),
+                    Type = "image",
+                    Offset = offset,
+                };
+                dir.Add (entry);
+                last_offset = offset;
+                index_pos += 4;
+            }
+            if (0 == dir.Count)
+                return null;
+            last_offset = file.MaxOffset;
+            for (int i = dir.Count-1; i >= 0; --i)
+            {
+                dir[i].Size = (uint)(last_offset - dir[i].Offset);
+                last_offset = dir[i].Offset;
+            }
+            return new ArcFile (file, this, dir);
+        }
+
+        public override IImageDecoder OpenImage (ArcFile arc, Entry entry)
+        {
+            var input = arc.File.CreateStream (entry.Offset, entry.Size);
+            try
+            {
+                return new DesertCgDecoder (input);
+            }
+            catch
+            {
+                input.Dispose();
+                throw;
+            }
+        }
+
+        internal static Dictionary<string, uint> FileNameTableMap = new Dictionary<string, uint> {
+            { @"..\DTime.exe", 0x49E348 },
+        };
+
+        List<string> LookupFileNameTable (ArcView file, int count)
+        {
+            try
+            {
+                var dir_name = Path.GetDirectoryName (file.Name);
+                foreach (var source in FileNameTableMap.Keys)
+                {
+                    var src_name = Path.Combine (dir_name, source);
+                    if (File.Exists (src_name))
+                    {
+                        using (var src = new ArcView (src_name))
+                        {
+                            var exe = new ExeFile (src);
+                            long offset = exe.GetAddressOffset (FileNameTableMap[source]);
+                            if (offset >= src.MaxOffset || offset + 0x104 * count > src.MaxOffset)
+                                return null;
+                            var dir = new List<string> (count);
+                            for (int i = 0; i < count; ++i)
+                            {
+                                var name = src.View.ReadString (offset, 0x104);
+                                dir.Add (name);
+                                offset += 0x104;
+                            }
+                            return dir;
+                        }
+                    }
+                }
+            }
+            catch { } // ignore errors
+            return null;
+        }
+    }
+
+    internal class DesertCgDecoder : BinaryImageDecoder
+    {
+        public DesertCgDecoder (IBinaryStream input) : base (input, ReadMetaData (input))
+        {
+        }
+
+        static ImageMetaData ReadMetaData (IBinaryStream input)
+        {
+            return new ImageMetaData {
+                Width  = input.ReadUInt32(),
+                Height = input.ReadUInt32(),
+                BPP = 8,
+            };
+        }
+
+        protected override ImageData GetImageData ()
+        {
+            m_input.Position = 8;
+            var palette = ImageFormat.ReadPalette (m_input.AsStream, 0x100, PaletteFormat.RgbX);
+            int stride = (Info.iWidth + 3) & ~3;
+            var pixels = m_input.ReadBytes (stride * Info.iHeight);
+            return ImageData.Create (Info, PixelFormats.Indexed8, palette, pixels, stride);
+        }
+    }
+}
+
+

ArcFormats/Triangle/ImageIAF.cs

@@ -100,7 +100,7 @@ namespace GameRes.Formats.Triangle
                 return null;
             unpacked_size &= (int)~0xC0000000;
             stream.Position = data_offset;
-            byte[] bmp = UnpackBitmap (stream.AsStream, pack_type, packed_size, 0x26);
+            byte[] bmp = UnpackBitmap (stream, pack_type, packed_size, 0x26);
             if (bmp[0] != 'B' && bmp[0] != 'C' || bmp[1] != 'M')
                 return null;
             return new IafMetaData
@@ -121,7 +121,7 @@ namespace GameRes.Formats.Triangle
         {
             var meta = (IafMetaData)info;
             stream.Position = meta.DataOffset;
-            var bitmap = UnpackBitmap (stream.AsStream, meta.PackType, meta.PackedSize, meta.UnpackedSize);
+            var bitmap = UnpackBitmap (stream, meta.PackType, meta.PackedSize, meta.UnpackedSize);
             if ('C' == bitmap[0])
             {
                 bitmap[0] = (byte)'B';
@@ -155,19 +155,24 @@ namespace GameRes.Formats.Triangle
                 return Bmp.Read (bmp, info);
         }
 
-        internal static byte[] UnpackBitmap (Stream stream, int pack_type, int packed_size, int unpacked_size)
+        internal static byte[] UnpackBitmap (IBinaryStream stream, int pack_type, int packed_size, int unpacked_size)
         {
             if (2 == pack_type)
             {
+                uint signature = stream.ReadUInt32();
+                stream.Seek (-4, SeekOrigin.Current);
                 using (var reader = new RleReader (stream, packed_size, unpacked_size))
                 {
+                    if (0x014D0142 == signature)
+                        reader.UnpackV2();
+                    else
                         reader.Unpack();
                     return reader.Data;
                 }
             }
             else if (0 == pack_type)
             {
-                using (var reader = new LzssReader (stream, packed_size, unpacked_size))
+                using (var reader = new LzssReader (stream.AsStream, packed_size, unpacked_size))
                 {
                     reader.Unpack();
                     return reader.Data;
@@ -261,15 +266,15 @@ namespace GameRes.Formats.Triangle
 
     internal class RleReader : IDataUnpacker, IDisposable
     {
-        BinaryReader    m_input;
+        IBinaryStream   m_input;
         byte[]          m_output;
         int             m_size;
 
         public byte[] Data { get { return m_output; } }
 
-        public RleReader (Stream input, int input_length, int output_length)
+        public RleReader (IBinaryStream input, int input_length, int output_length)
         {
-            m_input = new ArcView.Reader (input);
+            m_input = input;
             m_output = new byte[output_length];
             m_size = input_length;
         }
@@ -280,8 +285,8 @@ namespace GameRes.Formats.Triangle
             int dst = 0;
             while (dst < m_output.Length && src < m_size)
             {
-                byte b = m_input.ReadByte();
+                byte b = m_input.ReadUInt8();
-                int count = m_input.ReadByte();
+                int count = m_input.ReadUInt8();
                 src += 2;
                 count = Math.Min (count, m_output.Length - dst);
                 for (int i = 0; i < count; i++)
@@ -295,11 +300,11 @@ namespace GameRes.Formats.Triangle
             int dst = 0;
             while (dst < m_output.Length && src < m_size)
             {
-                byte ctl = m_input.ReadByte();
+                byte ctl = m_input.ReadUInt8();
                 ++src;
                 if (0 == ctl)
                 {
-                    int count = m_input.ReadByte();
+                    int count = m_input.ReadUInt8();
                     ++src;
                     count = Math.Min (count, m_output.Length - dst);
                     int read = m_input.Read (m_output, dst, count);
@@ -309,7 +314,7 @@ namespace GameRes.Formats.Triangle
                 else
                 {
                     int count = ctl;
-                    byte b = m_input.ReadByte();
+                    byte b = m_input.ReadUInt8();
                     ++src;
                     count = Math.Min (count, m_output.Length - dst);
 
@@ -320,24 +325,8 @@ namespace GameRes.Formats.Triangle
         }
 
         #region IDisposable Members
-        bool disposed = false;
-
         public void Dispose ()
         {
-            Dispose (true);
-            GC.SuppressFinalize (this);
-        }
-
-        protected virtual void Dispose (bool disposing)
-        {
-            if (!disposed)
-            {
-                if (disposing)
-                {
-                    m_input.Dispose();
-                }
-                disposed = true;
-            }
         }
         #endregion
     }