internal static WZObject ParseExtendedProperty(string name, WZBinaryReader r, WZObject parent, WZImage f,
bool encrypted)
{
string type = r.ReadWZStringBlock(encrypted);
switch (type)
{
case "Property":
r.Skip(2);
return(new WZSubProperty(name, parent, r, f));
case "Canvas":
return(new WZCanvasProperty(name, parent, r, f));
case "Shape2D#Vector2D":
return(new WZPointProperty(name, parent, r, f));
case "Shape2D#Convex2D":
return(new WZConvexProperty(name, parent, r, f));
case "Sound_DX8":
return(new WZAudioProperty(name, parent, r, f));
case "UOL":
r.Skip(1);
return(new WZLinkProperty(name, parent, r, f));
default:
return(WZUtil.Die <WZObject>($"Unknown ExtendedProperty type \"{type}\""));
}
}
private void Parse()
{
_r.Seek(0);
if (_r.PeekFor(() => _r.ReadWZStringBlock(true)) == "Property")
{
_encrypted = true;
}
else if (_r.PeekFor(() => _r.ReadWZStringBlock(false)) == "Property")
{
_encrypted = false;
}
else
{
WZUtil.Die("Failed to determine image encryption!");
}
_r.SkipWZStringBlock();
if (_r.ReadUInt16() != 0)
{
WZUtil.Die("WZImage with invalid header (no zero UInt16!)");
}
foreach (WZObject child in WZExtendedParser.ParsePropertyList(_r, this, this, _encrypted))
{
Add(child);
}
_parsed = true;
}
private static float ReadSingle(WZBinaryReader reader)
{
byte t = reader.ReadByte();
return(t == 0x80
? reader.ReadSingle()
: (t == 0 ? 0f : WZUtil.Die <float>("Unknown byte while reading WZSingleProperty.")));
}
// write function
/// <summary> 將指定位元組大小的資料寫入到緩衝區中，並將資料流位置往前移動 </summary>
/// <param name="buffer"> 要寫入的資料 </param>
/// <param name="length"> 要寫入的長度 </param>
/// <param name="encrypt"> 是否要進行加密 </param>
public void Write(byte[] buffer, int length, bool encrypt = false)
{
if (encrypt)
{
WZUtil.XORKey(buffer, length, this.KeyType);
}
this.BaseStream.Write(buffer, 0, length);
}
// read functions
/// <summary> 從目前的資料流讀取指定位元組大小的資料到指定的緩衝區內，並移動資料流指向的位置 </summary>
/// <param name="buffer"> 接收資料的資料緩衝區 </param>
/// <param name="length"> 需要讀取的資料長度 </param>
/// <param name="decrypt"> 是否需要進行解密 </param>
public void Read(byte[] buffer, int length, bool decrypt = false)
{
this.BaseStream.Read(buffer, 0, length);
if (decrypt)
{
WZUtil.XORKey(buffer, length, this.KeyType);
}
}
internal static List <WZObject> ParsePropertyList(WZBinaryReader r, WZObject parent, WZImage f, bool encrypted)
{
int num = r.ReadWZInt();
List <WZObject> ret = new List <WZObject>(num);
for (int i = 0; i < num; ++i)
{
string name = r.ReadWZStringBlock(encrypted);
byte type = r.ReadByte();
switch (type)
{
case 0:
ret.Add(new WZNullProperty(name, parent, f));
break;
case 0x0B:
case 2:
ret.Add(new WZUInt16Property(name, parent, r, f));
break;
case 0x13:
case 3:
ret.Add(new WZInt32Property(name, parent, r, f));
break;
case 0x14:
ret.Add(new WZInt64Property(name, parent, r, f));
break;
case 4:
ret.Add(new WZSingleProperty(name, parent, r, f));
break;
case 5:
ret.Add(new WZDoubleProperty(name, parent, r, f));
break;
case 8:
ret.Add(new WZStringProperty(name, parent, r, f));
break;
case 9:
uint blockLen = r.ReadUInt32();
ret.Add(ParseExtendedProperty(name, r.Clone(), parent, f, encrypted));
r.Skip(blockLen);
break;
default:
return
(WZUtil.Die <List <WZObject> >(
$"Unknown property type {type} at ParsePropertyList"));
}
}
return(ret);
}
private void Parse(WZBinaryReader wzbr, long offset)
{
wzbr.Seek(offset);
int entryCount = wzbr.ReadWZInt();
for (int i = 0; i < entryCount; ++i)
{
byte type = wzbr.ReadByte();
string name = null;
switch (type)
{
case 2:
int x = wzbr.ReadInt32();
wzbr.PeekFor(() => {
wzbr.Seek(x + File._fstart);
type = wzbr.ReadByte();
name = wzbr.ReadWZString(File._encrypted);
});
break;
case 3:
case 4:
name = wzbr.ReadWZString(File._encrypted);
break;
case 1:
// wzbr.Skip(10);
// continue;
default:
WZUtil.Die($"Unknown object type {type} in WzDirectory.");
break;
}
if (name == null)
{
WZUtil.Die("Failed to read WZDirectory entry name.");
}
int size = wzbr.ReadWZInt();
wzbr.ReadWZInt();
uint woffset = wzbr.ReadWZOffset(File._fstart);
switch (type)
{
case 3:
Add(new WZDirectory(name, this, File, wzbr.Clone(), woffset));
break;
case 4:
Add(new WZImage(name, this, File,
File.GetSubstream(woffset, size)));
break;
}
}
}
/// <summary> </summary>
public static uint GenerateOffsetKey(uint cur, uint off, int hash)
{
uint key = (uint)(((~(cur - off)) * hash) - 0x581C3F6D);
return(WZUtil._rotl(key, (byte)(key & 0x1F)));
}
internal override bool Parse(WZBinaryReader br, bool initial, out Bitmap result)
{
bool skip = (File._flag & WZReadSelection.NeverParseCanvas) == WZReadSelection.NeverParseCanvas,
eager = (File._flag & WZReadSelection.EagerParseCanvas) == WZReadSelection.EagerParseCanvas;
if (initial)
{
if (skip && eager)
{
result = null;
return(WZUtil.Die <bool>("Both NeverParseCanvas and EagerParseCanvas are set."));
}
br.Skip(1);
if (br.ReadByte() == 1)
{
br.Skip(2);
List <WZObject> l = WZExtendedParser.ParsePropertyList(br, this, Image, Image._encrypted);
if (ChildCount == 0)
{
l.ForEach(Add);
}
}
_afterChildren = br.Position;
}
else
{
br.Position = _afterChildren;
}
int width = br.ReadWZInt(); // width
int height = br.ReadWZInt(); // height
int format1 = br.ReadWZInt(); // format 1
int scale = br.ReadByte(); // format 2
br.Skip(4);
int blockLen = br.ReadInt32();
if ((initial || skip) && !eager)
{
br.Skip(blockLen); // block Len & png data
result = null;
return(skip);
}
else
{
br.Skip(1);
byte[] header = br.ReadBytes(2);
// FLG bit 5 indicates the presence of a preset dictionary
// seems like MS doesn't use that?
if ((header[1] & 0x20) != 0)
{
Debug.WriteLine("Warning; zlib with preset dictionary");
result = null;
br.Skip(blockLen - 3);
return(true);
}
// zlib header: CMF (byte), FLG (byte)
byte[] pngData = br.ReadBytes(blockLen - 3);
result = ParsePNG(width, height, format1, scale,
// CMF least significant bits 0 to 3 are compression method. only 8 is valid
(header[0] & 0xF) != 8 ||
// CMF << 8 | FLG i.e. header read as a big-endian short is a multiple of 31
(header[0] << 8 | header[1]) % 31 != 0
? DecryptPNG(pngData)
: pngData);
return(true);
}
}