mirror of
https://github.com/crskycode/GARbro.git
synced 2024-12-29 14:24:13 +08:00
572 lines
20 KiB
C#
572 lines
20 KiB
C#
//! \file ArcSWF.cs
|
|
//! \date 2018 Sep 16
|
|
//! \brief Shockwave Flash presentation.
|
|
//
|
|
// Copyright (C) 2018 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 System.Windows;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Imaging;
|
|
using GameRes.Compression;
|
|
|
|
namespace GameRes.Formats.Macromedia
|
|
{
|
|
internal class SwfEntry : Entry
|
|
{
|
|
public SwfChunk Chunk;
|
|
}
|
|
|
|
internal class SwfSoundEntry : SwfEntry
|
|
{
|
|
public readonly List<SwfChunk> SoundStream = new List<SwfChunk>();
|
|
}
|
|
|
|
[Export(typeof(ArchiveFormat))]
|
|
public class SwfOpener : ArchiveFormat
|
|
{
|
|
public override string Tag { get { return "SWF"; } }
|
|
public override string Description { get { return "Shockwave Flash presentation"; } }
|
|
public override uint Signature { get { return 0; } }
|
|
public override bool IsHierarchic { get { return false; } }
|
|
public override bool CanWrite { get { return false; } }
|
|
|
|
public SwfOpener ()
|
|
{
|
|
Signatures = new uint[] { 0x08535743, 0x08535746, 0 };
|
|
}
|
|
|
|
public override ArcFile TryOpen (ArcView file)
|
|
{
|
|
if (!file.View.AsciiEqual (0, "CWS") &&
|
|
!file.View.AsciiEqual (0, "FWS"))
|
|
return null;
|
|
bool is_compressed = file.View.ReadByte (0) == 'C';
|
|
int version = file.View.ReadByte (3);
|
|
using (var reader = new SwfReader (file.CreateStream(), version, is_compressed))
|
|
{
|
|
var chunks = reader.Parse();
|
|
var base_name = Path.GetFileNameWithoutExtension (file.Name);
|
|
var dir = chunks.Where (t => t.Length > 2 && TypeMap.ContainsKey (t.Type))
|
|
.Select (t => new SwfEntry {
|
|
Name = string.Format ("{0}#{1:D5}", base_name, t.Id),
|
|
Type = GetTypeFromId (t.Type),
|
|
Chunk = t,
|
|
Offset = 0,
|
|
Size = (uint)t.Length
|
|
} as Entry).ToList();
|
|
SwfSoundEntry current_stream = null;
|
|
foreach (var chunk in chunks.Where (t => IsSoundStream (t)))
|
|
{
|
|
switch (chunk.Type)
|
|
{
|
|
case Types.SoundStreamHead:
|
|
case Types.SoundStreamHead2:
|
|
if ((chunk.Data[1] & 0x30) != 0x20) // not mp3 stream
|
|
{
|
|
current_stream = null;
|
|
continue;
|
|
}
|
|
current_stream = new SwfSoundEntry {
|
|
Name = string.Format ("{0}#{1:D5}", base_name, chunk.Id),
|
|
Type = "audio",
|
|
Chunk = chunk,
|
|
Offset = 0,
|
|
};
|
|
dir.Add (current_stream);
|
|
break;
|
|
|
|
case Types.SoundStreamBlock:
|
|
if (current_stream != null)
|
|
{
|
|
current_stream.Size += (uint)(chunk.Data.Length - 4);
|
|
current_stream.SoundStream.Add (chunk);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return new ArcFile (file, this, dir);
|
|
}
|
|
}
|
|
|
|
public override Stream OpenEntry (ArcFile arc, Entry entry)
|
|
{
|
|
var swent = (SwfEntry)entry;
|
|
Extractor extract;
|
|
if (!ExtractMap.TryGetValue (swent.Chunk.Type, out extract))
|
|
extract = ExtractChunk;
|
|
return extract (swent);
|
|
}
|
|
|
|
static string GetTypeFromId (Types type_id)
|
|
{
|
|
string type;
|
|
if (TypeMap.TryGetValue (type_id, out type))
|
|
return type;
|
|
return type_id.ToString();
|
|
}
|
|
|
|
static Stream ExtractChunk (SwfEntry entry)
|
|
{
|
|
return new BinMemoryStream (entry.Chunk.Data);
|
|
}
|
|
|
|
static Stream ExtractChunkContents (SwfEntry entry)
|
|
{
|
|
var source = entry.Chunk;
|
|
return new BinMemoryStream (source.Data, 2, source.Length-2);
|
|
}
|
|
|
|
static Stream ExtractSoundStream (SwfEntry entry)
|
|
{
|
|
var swe = (SwfSoundEntry)entry;
|
|
var output = new MemoryStream ((int)swe.Size);
|
|
foreach (var chunk in swe.SoundStream)
|
|
output.Write (chunk.Data, 4, chunk.Data.Length-4);
|
|
output.Position = 0;
|
|
return output;
|
|
}
|
|
|
|
static Stream ExtractAudio (SwfEntry entry)
|
|
{
|
|
var chunk = entry.Chunk;
|
|
int flags = chunk.Data[2];
|
|
int format = flags >> 4;
|
|
if (2 == format)
|
|
return new BinMemoryStream (chunk.Data, 9, chunk.Length-9);
|
|
int sample_rate = (flags >> 2) & 3;
|
|
int bits_per_sample = (flags & 2) != 0 ? 16 : 8;
|
|
int channels = (flags & 1) + 1;
|
|
|
|
return new BinMemoryStream (chunk.Data, 2, chunk.Length-2);
|
|
}
|
|
|
|
public override IImageDecoder OpenImage (ArcFile arc, Entry entry)
|
|
{
|
|
var swent = (SwfEntry)entry;
|
|
switch (swent.Chunk.Type)
|
|
{
|
|
case Types.DefineBitsLossless:
|
|
case Types.DefineBitsLossless2:
|
|
return new LosslessImageDecoder (swent.Chunk);
|
|
|
|
case Types.DefineBitsJpeg2:
|
|
return new SwfJpeg2Decoder (swent.Chunk);
|
|
|
|
case Types.DefineBitsJpeg3:
|
|
return new SwfJpeg3Decoder (swent.Chunk);
|
|
|
|
case Types.DefineBitsJpeg:
|
|
return OpenBitsJpeg (swent.Chunk);
|
|
|
|
default:
|
|
return base.OpenImage (arc, entry);
|
|
}
|
|
}
|
|
|
|
IImageDecoder OpenBitsJpeg (SwfChunk chunk)
|
|
{
|
|
int jpeg_pos = 0;
|
|
for (int i = 0; i < chunk.Data.Length - 2; ++i)
|
|
{
|
|
if (chunk.Data[i] == 0xFF && chunk.Data[i+1] == 0xD8)
|
|
{
|
|
jpeg_pos = i;
|
|
break;
|
|
}
|
|
}
|
|
var input = new BinMemoryStream (chunk.Data, jpeg_pos, chunk.Data.Length - jpeg_pos);
|
|
return ImageFormatDecoder.Create (input);
|
|
}
|
|
|
|
delegate Stream Extractor (SwfEntry entry);
|
|
|
|
static Dictionary<Types, Extractor> ExtractMap = new Dictionary<Types, Extractor> {
|
|
// { Types.DoAction, ExtractChunkContents },
|
|
{ Types.DefineBitsJpeg, ExtractChunkContents },
|
|
{ Types.DefineBitsLossless, ExtractChunk },
|
|
{ Types.DefineBitsLossless2, ExtractChunk },
|
|
{ Types.DefineSound, ExtractAudio },
|
|
{ Types.SoundStreamHead, ExtractSoundStream },
|
|
{ Types.SoundStreamHead2, ExtractSoundStream },
|
|
};
|
|
|
|
static Dictionary<Types, string> TypeMap = new Dictionary<Types, string> {
|
|
{ Types.DefineBitsJpeg, "image" },
|
|
{ Types.DefineBitsJpeg2, "image" },
|
|
{ Types.DefineBitsJpeg3, "image" },
|
|
{ Types.DefineBitsLossless, "image" },
|
|
{ Types.DefineBitsLossless2, "image" },
|
|
{ Types.DefineSound, "audio" },
|
|
{ Types.DoAction, "" },
|
|
|
|
{ Types.JpegTables, "JpegTables" },
|
|
/*
|
|
{ Types.DefineText, "Text" },
|
|
{ Types.DefineText2, "Text2" },
|
|
{ Types.DefineVideoStream, "VideoStream" },
|
|
{ Types.VideoFrame, "VideoFrame" },
|
|
*/
|
|
};
|
|
|
|
internal static bool IsSoundStream (SwfChunk chunk)
|
|
{
|
|
return chunk.Type == Types.SoundStreamHead
|
|
|| chunk.Type == Types.SoundStreamHead2
|
|
|| chunk.Type == Types.SoundStreamBlock;
|
|
}
|
|
}
|
|
|
|
internal enum Types : short
|
|
{
|
|
End = 0,
|
|
ShowFrame = 1,
|
|
DefineShape = 2,
|
|
DefineBitsJpeg = 6,
|
|
JpegTables = 8,
|
|
DefineText = 11,
|
|
DoAction = 12,
|
|
DefineSound = 14,
|
|
SoundStreamHead = 18,
|
|
SoundStreamBlock = 19,
|
|
DefineBitsLossless = 20,
|
|
DefineBitsJpeg2 = 21,
|
|
DefineShape2 = 22,
|
|
DefineShape3 = 32,
|
|
DefineText2 = 33,
|
|
DefineBitsJpeg3 = 35,
|
|
DefineBitsLossless2 = 36,
|
|
DefineSprite = 39,
|
|
SoundStreamHead2 = 45,
|
|
ExportAssets = 56,
|
|
DefineVideoStream = 60,
|
|
VideoFrame = 61,
|
|
FileAttributes = 69,
|
|
Font3 = 75,
|
|
DefineBinary = 87,
|
|
};
|
|
|
|
internal class SwfChunk
|
|
{
|
|
public Types Type;
|
|
public byte[] Data;
|
|
|
|
public int Length { get { return Data.Length; } }
|
|
public int Id { get { return Data.Length > 2 ? Data.ToUInt16 (0) : -1; } }
|
|
|
|
public SwfChunk (Types id, int length)
|
|
{
|
|
Type = id;
|
|
Data = length > 0 ? new byte[length] : Array.Empty<byte>();
|
|
}
|
|
}
|
|
|
|
internal sealed class SwfReader : IDisposable
|
|
{
|
|
IBinaryStream m_input;
|
|
MsbBitStream m_bits;
|
|
int m_version;
|
|
|
|
Int32Rect m_dim;
|
|
|
|
public SwfReader (IBinaryStream input, int version, bool is_compressed)
|
|
{
|
|
m_input = input;
|
|
m_version = version;
|
|
m_input.Position = 8;
|
|
if (is_compressed)
|
|
{
|
|
var zstream = new ZLibStream (input.AsStream, CompressionMode.Decompress);
|
|
m_input = new BinaryStream (zstream, m_input.Name);
|
|
}
|
|
m_bits = new MsbBitStream (m_input.AsStream, true);
|
|
}
|
|
|
|
int m_frame_rate;
|
|
int m_frame_count;
|
|
|
|
List<SwfChunk> m_chunks = new List<SwfChunk>();
|
|
|
|
public List<SwfChunk> Parse ()
|
|
{
|
|
ReadDimensions();
|
|
m_bits.Reset();
|
|
m_frame_rate = m_input.ReadUInt16();
|
|
m_frame_count = m_input.ReadUInt16();
|
|
for (;;)
|
|
{
|
|
var chunk = ReadChunk();
|
|
if (null == chunk)
|
|
break;
|
|
m_chunks.Add (chunk);
|
|
}
|
|
return m_chunks;
|
|
}
|
|
|
|
void ReadDimensions ()
|
|
{
|
|
int rsize = m_bits.GetBits (5);
|
|
m_dim.X = GetSignedBits (rsize);
|
|
m_dim.Y = GetSignedBits (rsize);
|
|
m_dim.Width = GetSignedBits (rsize) - m_dim.X;
|
|
m_dim.Height = GetSignedBits (rsize) - m_dim.Y;
|
|
}
|
|
|
|
byte[] m_buffer = new byte[4];
|
|
|
|
SwfChunk ReadChunk ()
|
|
{
|
|
if (m_input.Read (m_buffer, 0, 2) != 2)
|
|
return null;
|
|
int length = m_buffer.ToUInt16 (0);
|
|
Types id = (Types)(length >> 6);
|
|
length &= 0x3F;
|
|
if (0x3F == length)
|
|
length = m_input.ReadInt32();
|
|
if (Types.DefineSprite == id)
|
|
length = 4;
|
|
var chunk = new SwfChunk (id, length);
|
|
if (length > 0)
|
|
{
|
|
if (m_input.Read (chunk.Data, 0, length) < length)
|
|
return null;
|
|
}
|
|
return chunk;
|
|
}
|
|
|
|
int GetSignedBits (int count)
|
|
{
|
|
int v = m_bits.GetBits (count);
|
|
if ((v >> (count - 1)) != 0)
|
|
v |= -1 << count;
|
|
return v;
|
|
}
|
|
|
|
#region IDisposable Members
|
|
bool m_disposed = false;
|
|
public void Dispose ()
|
|
{
|
|
if (!m_disposed)
|
|
{
|
|
m_input.Dispose();
|
|
m_bits.Dispose();
|
|
m_disposed = true;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
internal sealed class LosslessImageDecoder : BinaryImageDecoder
|
|
{
|
|
Types m_type;
|
|
int m_colors;
|
|
int m_data_pos;
|
|
|
|
public PixelFormat Format { get; private set; }
|
|
private bool HasAlpha { get { return m_type == Types.DefineBitsLossless2; } }
|
|
|
|
public LosslessImageDecoder (SwfChunk chunk) : base (new BinMemoryStream (chunk.Data))
|
|
{
|
|
m_type = chunk.Type;
|
|
byte format = chunk.Data[2];
|
|
int bpp;
|
|
switch (format)
|
|
{
|
|
case 3:
|
|
bpp = 8; Format = PixelFormats.Indexed8;
|
|
break;
|
|
case 4:
|
|
bpp = 16; Format = PixelFormats.Bgr565;
|
|
break;
|
|
case 5:
|
|
bpp = 32;
|
|
Format = HasAlpha ? PixelFormats.Bgra32 : PixelFormats.Bgr32;
|
|
break;
|
|
default: throw new InvalidFormatException();
|
|
}
|
|
uint width = chunk.Data.ToUInt16 (3);
|
|
uint height = chunk.Data.ToUInt16 (5);
|
|
m_colors = 0;
|
|
m_data_pos = 7;
|
|
if (3 == format)
|
|
m_colors = chunk.Data[m_data_pos++] + 1;
|
|
Info = new ImageMetaData {
|
|
Width = width, Height = height, BPP = bpp
|
|
};
|
|
}
|
|
|
|
protected override ImageData GetImageData ()
|
|
{
|
|
m_input.Position = m_data_pos;
|
|
using (var input = new ZLibStream (m_input.AsStream, CompressionMode.Decompress, true))
|
|
{
|
|
BitmapPalette palette = null;
|
|
if (8 == Info.BPP)
|
|
{
|
|
var pal_format = HasAlpha ? PaletteFormat.RgbA : PaletteFormat.RgbX;
|
|
palette = ImageFormat.ReadPalette (input, m_colors, pal_format);
|
|
}
|
|
var pixels = new byte[(int)Info.Width * (int)Info.Height * (Info.BPP / 8)];
|
|
input.Read (pixels, 0, pixels.Length);
|
|
if (32 == Info.BPP)
|
|
{
|
|
for (int i = 0; i < pixels.Length; i += 4)
|
|
{
|
|
byte a = pixels[i];
|
|
byte r = pixels[i+1];
|
|
byte g = pixels[i+2];
|
|
byte b = pixels[i+3];
|
|
pixels[i] = b;
|
|
pixels[i+1] = g;
|
|
pixels[i+2] = r;
|
|
pixels[i+3] = a;
|
|
}
|
|
}
|
|
return ImageData.Create (Info, Format, palette, pixels);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class SwfJpeg2Decoder : IImageDecoder
|
|
{
|
|
byte[] m_input;
|
|
ImageData m_image;
|
|
|
|
public Stream Source { get { return Stream.Null; } }
|
|
public ImageFormat SourceFormat { get { return null; } }
|
|
public ImageMetaData Info { get; private set; }
|
|
public ImageData Image { get { return m_image ?? (m_image = Unpack()); } }
|
|
|
|
public SwfJpeg2Decoder (SwfChunk chunk)
|
|
{
|
|
m_input = chunk.Data;
|
|
}
|
|
|
|
ImageData Unpack ()
|
|
{
|
|
int jpeg_pos = FindJpegSignature();
|
|
if (jpeg_pos < 0)
|
|
throw new InvalidFormatException();
|
|
using (var jpeg = new BinMemoryStream (m_input, jpeg_pos, m_input.Length-jpeg_pos))
|
|
{
|
|
var decoder = new JpegBitmapDecoder (jpeg, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
|
|
var frame = decoder.Frames[0];
|
|
Info = new ImageMetaData {
|
|
Width = (uint)frame.PixelWidth,
|
|
Height = (uint)frame.PixelHeight,
|
|
BPP = frame.Format.BitsPerPixel,
|
|
};
|
|
return new ImageData (frame, Info);
|
|
}
|
|
}
|
|
|
|
int FindJpegSignature ()
|
|
{
|
|
int jpeg_pos = 2;
|
|
while (jpeg_pos < m_input.Length-4)
|
|
{
|
|
if (m_input[jpeg_pos] != 0xFF)
|
|
jpeg_pos++;
|
|
else if (m_input[jpeg_pos+1] == 0xD8)
|
|
return jpeg_pos;
|
|
else if (m_input[jpeg_pos+1] != 0xD9)
|
|
jpeg_pos++;
|
|
else if (m_input[jpeg_pos+2] != 0xFF)
|
|
jpeg_pos += 3;
|
|
else if (m_input[jpeg_pos+3] != 0xD8)
|
|
jpeg_pos += 2;
|
|
else
|
|
return jpeg_pos+4;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public void Dispose ()
|
|
{
|
|
}
|
|
}
|
|
|
|
internal sealed class SwfJpeg3Decoder : IImageDecoder
|
|
{
|
|
byte[] m_input;
|
|
ImageData m_image;
|
|
int m_jpeg_length;
|
|
|
|
public Stream Source { get { return Stream.Null; } }
|
|
public ImageFormat SourceFormat { get { return null; } }
|
|
public ImageMetaData Info { get; private set; }
|
|
public PixelFormat Format { get; private set; }
|
|
public ImageData Image { get { return m_image ?? (m_image = Unpack()); } }
|
|
|
|
public SwfJpeg3Decoder (SwfChunk chunk)
|
|
{
|
|
m_input = chunk.Data;
|
|
m_jpeg_length = m_input.ToInt32 (2);
|
|
}
|
|
|
|
ImageData Unpack ()
|
|
{
|
|
BitmapSource image;
|
|
using (var jpeg = new BinMemoryStream (m_input, 6, m_jpeg_length))
|
|
{
|
|
var decoder = new JpegBitmapDecoder (jpeg, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
|
|
image = decoder.Frames[0];
|
|
}
|
|
Info = new ImageMetaData {
|
|
Width = (uint)image.PixelWidth,
|
|
Height = (uint)image.PixelHeight,
|
|
BPP = image.Format.BitsPerPixel,
|
|
};
|
|
byte[] alpha = new byte[image.PixelWidth * image.PixelHeight];
|
|
using (var input = new BinMemoryStream (m_input, 6 + m_jpeg_length, m_input.Length - (6+m_jpeg_length)))
|
|
using (var alpha_data = new ZLibStream (input, CompressionMode.Decompress))
|
|
{
|
|
alpha_data.Read (alpha, 0, alpha.Length);
|
|
}
|
|
if (image.Format.BitsPerPixel != 32)
|
|
image = new FormatConvertedBitmap (image, PixelFormats.Bgr32, null, 0);
|
|
int stride = image.PixelWidth * 4;
|
|
var pixels = new byte[stride * image.PixelHeight];
|
|
image.CopyPixels (pixels, stride, 0);
|
|
ApplyAlpha (pixels, alpha);
|
|
return ImageData.Create (Info, PixelFormats.Bgra32, null, pixels, stride);
|
|
}
|
|
|
|
void ApplyAlpha (byte[] pixels, byte[] alpha)
|
|
{
|
|
int src = 0;
|
|
for (int dst = 3; dst < pixels.Length; dst += 4)
|
|
{
|
|
pixels[dst] = alpha[src++];
|
|
}
|
|
}
|
|
|
|
public void Dispose ()
|
|
{
|
|
}
|
|
}
|
|
}
|