public MSCabCompression(Stream stream)
{
this.stream = stream;
var signature = stream.ReadASCII(4);
if (signature != "MSCF")
throw new InvalidDataException("Not a Microsoft CAB package!");
stream.Position += 12;
var filesOffset = stream.ReadUInt32();
stream.Position += 6;
var folderCount = stream.ReadUInt16();
var fileCount = stream.ReadUInt16();
if (stream.ReadUInt16() != 0)
throw new InvalidDataException("Only plain packages (without reserved header space or prev/next archives) are supported!");
stream.Position += 4;
folders = new CabFolder[folderCount];
for (var i = 0; i < folderCount; i++)
{
folders[i] = new CabFolder(stream);
if (folders[i].CompressionType != 1)
throw new InvalidDataException("Compression type is not supported");
}
files = new CabFile[fileCount];
stream.Seek(filesOffset, SeekOrigin.Begin);
for (var i = 0; i < fileCount; i++)
files[i] = new CabFile(stream);
}
public MixFile(string filename, PackageHashType type, int priority)
{
this.filename = filename;
this.priority = priority;
this.type = type;
s = GlobalFileSystem.Open(filename);
// Detect format type
s.Seek(0, SeekOrigin.Begin);
var isCncMix = s.ReadUInt16() != 0;
// The C&C mix format doesn't contain any flags or encryption
var isEncrypted = false;
if (!isCncMix)
isEncrypted = (s.ReadUInt16() & 0x2) != 0;
List<PackageEntry> entries;
if (isEncrypted)
{
long unused;
entries = ParseHeader(DecryptHeader(s, 4, out dataStart), 0, out unused);
}
else
entries = ParseHeader(s, isCncMix ? 0 : 4, out dataStart);
index = entries.ToDictionaryWithConflictLog(x => x.Hash,
"{0} ({1} format, Encrypted: {2}, DataStart: {3})".F(filename, (isCncMix ? "C&C" : "RA/TS/RA2"), isEncrypted, dataStart),
null, x => "(offs={0}, len={1})".F(x.Offset, x.Length)
);
}
public ShpReader(Stream stream)
{
imageCount = stream.ReadUInt16();
stream.Position += 4;
var width = stream.ReadUInt16();
var height = stream.ReadUInt16();
Size = new Size(width, height);
stream.Position += 4;
for (var i = 0; i < imageCount; i++)
headers.Add(new ImageHeader(stream, this));
// Skip eof and zero headers
stream.Position += 16;
var offsets = headers.ToDictionary(h => h.FileOffset, h => h);
for (var i = 0; i < imageCount; i++)
{
var h = headers[i];
if (h.Format == Format.Format20)
h.RefImage = headers[i - 1];
else if (h.Format == Format.Format40 && !offsets.TryGetValue(h.RefOffset, out h.RefImage))
throw new InvalidDataException("Reference doesnt point to image data {0}->{1}".F(h.FileOffset, h.RefOffset));
}
foreach (var h in headers)
Decompress(stream, h);
spriteFrames = Exts.Lazy(() => headers.Cast<ISpriteFrame>());
}
public ShpReader(Stream stream)
{
imageCount = stream.ReadUInt16();
stream.Position += 4;
var width = stream.ReadUInt16();
var height = stream.ReadUInt16();
Size = new Size(width, height);
stream.Position += 4;
var headers = new ImageHeader[imageCount];
Frames = headers.AsReadOnly();
for (var i = 0; i < headers.Length; i++)
headers[i] = new ImageHeader(stream, this);
// Skip eof and zero headers
stream.Position += 16;
var offsets = headers.ToDictionary(h => h.FileOffset, h => h);
for (var i = 0; i < imageCount; i++)
{
var h = headers[i];
if (h.Format == Format.Format20)
h.RefImage = headers[i - 1];
else if (h.Format == Format.Format40 && !offsets.TryGetValue(h.RefOffset, out h.RefImage))
throw new InvalidDataException("Reference doesnt point to image data {0}->{1}".F(h.FileOffset, h.RefOffset));
}
shpBytesFileOffset = stream.Position;
shpBytes = stream.ReadBytes((int)(stream.Length - stream.Position));
foreach (var h in headers)
Decompress(h);
}
TmpTDFrame[] ParseFrames(Stream s)
{
var start = s.Position;
var width = s.ReadUInt16();
var height = s.ReadUInt16();
var size = new Size(width, height);
s.Position += 8;
var imgStart = s.ReadUInt32();
s.Position += 8;
var indexEnd = s.ReadInt32();
var indexStart = s.ReadInt32();
s.Position = indexStart;
var count = indexEnd - indexStart;
var tiles = new TmpTDFrame[count];
var tilesIndex = 0;
foreach (var b in s.ReadBytes(count))
{
if (b != 255)
{
s.Position = imgStart + b * width * height;
tiles[tilesIndex++] = new TmpTDFrame(s.ReadBytes(width * height), size);
}
else
tiles[tilesIndex++] = new TmpTDFrame(null, size);
}
s.Position = start;
return tiles;
}
public MixFile(FileSystem context, string filename)
{
Name = filename;
this.context = context;
s = context.Open(filename);
try
{
// Detect format type
var isCncMix = s.ReadUInt16() != 0;
// The C&C mix format doesn't contain any flags or encryption
var isEncrypted = false;
if (!isCncMix)
isEncrypted = (s.ReadUInt16() & 0x2) != 0;
List<PackageEntry> entries;
if (isEncrypted)
{
long unused;
entries = ParseHeader(DecryptHeader(s, 4, out dataStart), 0, out unused);
}
else
entries = ParseHeader(s, isCncMix ? 0 : 4, out dataStart);
index = ParseIndex(entries.ToDictionaryWithConflictLog(x => x.Hash,
"{0} ({1} format, Encrypted: {2}, DataStart: {3})".F(filename, isCncMix ? "C&C" : "RA/TS/RA2", isEncrypted, dataStart),
null, x => "(offs={0}, len={1})".F(x.Offset, x.Length)));
}
catch (Exception)
{
Dispose();
throw;
}
}
public Container(Stream stream)
{
UInt16 stringLength = stream.ReadUInt16();
Name = stream.ReadAsciiString(stringLength);
ContainerType = stream.ReadUInt8();
Flags = (ContainerFlags)stream.ReadUInt16();
PrimitiveCount = stream.ReadUInt16();
PackfileBaseOffset = stream.ReadUInt32();
CompressionType = stream.ReadUInt8();
stringLength = stream.ReadUInt16();
StubContainerParentName = stream.ReadAsciiString(stringLength);
Int32 auxDataSize = stream.ReadInt32();
AuxData = new byte[auxDataSize];
stream.Read(AuxData, 0, auxDataSize);
TotalCompressedPackfileReadSize = stream.ReadInt32();
Primitives = new List<Primitive>();
PrimitiveSizes = new List<WriteTimeSizes>();
for (UInt16 i = 0; i < PrimitiveCount; i++)
{
var sizes = stream.ReadStruct<WriteTimeSizes>();
PrimitiveSizes.Add(sizes);
}
for (UInt16 i = 0; i < PrimitiveCount; i++)
{
Primitive primitive = new Primitive(stream);
Primitives.Add(primitive);
}
}
bool IsWsaD2(Stream s)
{
if (s.Length < 10)
return false;
var start = s.Position;
numTiles = s.ReadUInt16();
tileWidth = s.ReadUInt16();
tileHeight = s.ReadUInt16();
Delta = s.ReadUInt32();
offsets = new uint[numTiles + 1];
for (var i = 0; i <= numTiles; i++)
offsets[i] = s.ReadUInt32();
s.Position = start;
//if (offsets[numTiles] < s.Length)
// return false;
if (offsets[0] == 0)
{
numTiles -= 1;
for (var i = 1; i <= numTiles; i++)
offsets[i - 1] = offsets[i];
}
return true;
}
public static Chunk Read(Stream s)
{
Chunk c;
c.CompressedSize = s.ReadUInt16();
c.OutputSize = s.ReadUInt16();
if (0xdeaf != s.ReadUInt32())
throw new InvalidDataException("Chunk header is bogus");
return c;
}
public ImageHeader(Stream stream, ShpReader reader)
{
this.reader = reader;
var data = stream.ReadUInt32();
FileOffset = data & 0xffffff;
Format = (Format)(data >> 24);
RefOffset = stream.ReadUInt16();
RefFormat = (Format)stream.ReadUInt16();
}
public InstallShieldPackage(FileSystem context, string filename)
{
Name = filename;
s = context.Open(filename);
try
{
// Parse package header
var signature = s.ReadUInt32();
if (signature != 0x8C655D13)
throw new InvalidDataException("Not an Installshield package");
s.Position += 8;
/*var FileCount = */s.ReadUInt16();
s.Position += 4;
/*var ArchiveSize = */s.ReadUInt32();
s.Position += 19;
var tocAddress = s.ReadInt32();
s.Position += 4;
var dirCount = s.ReadUInt16();
// Parse the directory list
s.Position = tocAddress;
// Parse directories
var directories = new Dictionary<string, uint>();
for (var i = 0; i < dirCount; i++)
{
// Parse directory header
var fileCount = s.ReadUInt16();
var chunkSize = s.ReadUInt16();
var nameLength = s.ReadUInt16();
var dirName = s.ReadASCII(nameLength);
// Skip to the end of the chunk
s.ReadBytes(chunkSize - nameLength - 6);
directories.Add(dirName, fileCount);
}
// Parse files
foreach (var dir in directories)
for (var i = 0; i < dir.Value; i++)
ParseFile(s, dir.Key);
}
catch
{
Dispose();
throw;
}
}
public ShpD2Frame(Stream s)
{
var flags = (FormatFlags)s.ReadUInt16();
s.Position += 1;
var width = s.ReadUInt16();
var height = s.ReadUInt8();
Size = new Size(width, height);
// Subtract header size
var dataLeft = s.ReadUInt16() - 10;
var dataSize = s.ReadUInt16();
byte[] table;
if ((flags & FormatFlags.PaletteTable) != 0)
{
var n = (flags & FormatFlags.VariableLengthTable) != 0 ? s.ReadUInt8() : (byte)16;
table = new byte[n];
for (var i = 0; i < n; i++)
table[i] = s.ReadUInt8();
dataLeft -= n;
}
else
{
table = new byte[256];
for (var i = 0; i < 256; i++)
table[i] = (byte)i;
table[1] = 0x7f;
table[2] = 0x7e;
table[3] = 0x7d;
table[4] = 0x7c;
}
Data = new byte[width * height];
// Decode image data
var compressed = s.ReadBytes(dataLeft);
if ((flags & FormatFlags.SkipFormat80) == 0)
{
var temp = new byte[dataSize];
Format80.DecodeInto(compressed, temp);
compressed = temp;
}
Format2.DecodeInto(compressed, Data, 0);
// Lookup values in lookup table
for (var j = 0; j < Data.Length; j++)
Data[j] = table[Data[j]];
}
private string ReadStringFromPositionAndReset( Stream s, uint stringPosition )
{
long pos = s.Position;
s.Position = stringPosition;
StringBuilder sb = new StringBuilder();
byte[] buffer = new byte[2];
int b = s.ReadByte();
while ( b != 0 && b != -1 ) {
if ( b == 0x01 ) {
sb.Append( '\n' );
} else if ( b == 0x02 ) {
if ( s.ReadByte() != 0x00 ) { throw new Exception( "control code 0x02 not followed by a null byte!" ); }
sb.AppendFormat( "<Voice: {0:x4}>", s.ReadUInt16() );
} else if ( b == 0x03 ) {
throw new Exception( "unknown control code 0x03" );
} else if ( b == 0x04 ) {
throw new Exception( "unknown control code 0x04" );
} else if ( ( b > 0x04 && b <= 0x80 ) || ( b >= 0xA0 && b <= 0xDF ) ) {
// is a single byte
buffer[0] = (byte)b;
sb.Append( Util.ShiftJISEncoding.GetString( buffer, 0, 1 ) );
} else {
// is two bytes
buffer[0] = (byte)b;
buffer[1] = (byte)s.ReadByte();
sb.Append( Util.ShiftJISEncoding.GetString( buffer ) );
}
b = s.ReadByte();
}
s.Position = pos;
return sb.ToString();
}
static bool IsShpTD(Stream s)
{
var start = s.Position;
// First word is the image count
var imageCount = s.ReadUInt16();
if (imageCount == 0)
{
s.Position = start;
return false;
}
// Last offset should point to the end of file
var finalOffset = start + 14 + 8 * imageCount;
if (finalOffset > s.Length)
{
s.Position = start;
return false;
}
s.Position = finalOffset;
var eof = s.ReadUInt32();
if (eof != s.Length)
{
s.Position = start;
return false;
}
// Check the format flag on the first frame
s.Position = start + 17;
var b = s.ReadUInt8();
s.Position = start;
return b == 0x20 || b == 0x40 || b == 0x80;
}
ShpTSFrame[] ParseFrames(Stream s)
{
var start = s.Position;
s.ReadUInt16();
var width = s.ReadUInt16();
var height = s.ReadUInt16();
var size = new Size(width, height);
var frameCount = s.ReadUInt16();
var frames = new ShpTSFrame[frameCount];
for (var i = 0; i < frames.Length; i++)
frames[i] = new ShpTSFrame(s, size);
s.Position = start;
return frames;
}
bool IsTmpRA(Stream s)
{
var start = s.Position;
s.Position += 20;
var a = s.ReadUInt32();
s.Position += 2;
var b = s.ReadUInt16();
s.Position = start;
return a == 0 && b == 0x2c73;
}
public ShpD2Reader(Stream s)
{
var imageCount = s.ReadUInt16();
// Last offset is pointer to end of file.
var offsets = new uint[imageCount + 1];
var temp = s.ReadUInt32();
// If fourth byte in file is non-zero, the offsets are two bytes each.
var twoByteOffset = (temp & 0xFF0000) > 0;
s.Position = 2;
for (var i = 0; i < imageCount + 1; i++)
offsets[i] = (twoByteOffset ? s.ReadUInt16() : s.ReadUInt32()) + 2;
for (var i = 0; i < imageCount; i++)
{
s.Position = offsets[i];
frames.Add(new Frame(s));
}
}
static List<PackageEntry> ParseHeader(Stream s, long offset, out long headerEnd)
{
s.Seek(offset, SeekOrigin.Begin);
var numFiles = s.ReadUInt16();
/*uint dataSize = */s.ReadUInt32();
var items = new List<PackageEntry>();
for (var i = 0; i < numFiles; i++)
items.Add(new PackageEntry(s));
headerEnd = offset + 6 + numFiles*PackageEntry.Size;
return items;
}
public BinaryDataHeader(Stream s, int2 expectedSize)
{
Format = s.ReadUInt8();
var width = s.ReadUInt16();
var height = s.ReadUInt16();
if (width != expectedSize.X || height != expectedSize.Y)
throw new InvalidDataException("Invalid tile data");
if (Format == 1)
{
TilesOffset = 5;
HeightsOffset = 0;
ResourcesOffset = (uint)(3 * width * height + 5);
}
else if (Format == 2)
{
TilesOffset = s.ReadUInt32();
HeightsOffset = s.ReadUInt32();
ResourcesOffset = s.ReadUInt32();
}
else
throw new InvalidDataException("Unknown binary map format '{0}'".F(Format));
}
bool IsShpD2(Stream s)
{
var start = s.Position;
// First word is the image count
var imageCount = s.ReadUInt16();
if (imageCount == 0)
{
s.Position = start;
return false;
}
// Test for two vs four byte offset
var testOffset = s.ReadUInt32();
var offsetSize = (testOffset & 0xFF0000) > 0 ? 2 : 4;
// Last offset should point to the end of file
var finalOffset = start + 2 + offsetSize * imageCount;
if (finalOffset > s.Length)
{
s.Position = start;
return false;
}
s.Position = finalOffset;
var eof = offsetSize == 2 ? s.ReadUInt16() : s.ReadUInt32();
if (eof + 2 != s.Length)
{
s.Position = start;
return false;
}
// Check the format flag on the first frame
var b = s.ReadUInt16();
s.Position = start;
return b == 5 || b <= 3;
}
public Stream2File(Stream stream)
{
Header = stream.ReadStruct<ContainerFileHeader>();
uint allocatorTypeCount = stream.ReadUInt32();
for (uint i = 0; i < allocatorTypeCount; i++)
{
UInt16 stringLength = stream.ReadUInt16();
string name = stream.ReadAsciiString(stringLength);
byte id = stream.ReadUInt8();
AllocatorTypes.Add(id, name);
}
uint primitiveTypeCount = stream.ReadUInt32();
for (uint i = 0; i < primitiveTypeCount; i++)
{
UInt16 stringLength = stream.ReadUInt16();
string name = stream.ReadAsciiString(stringLength);
byte id = stream.ReadUInt8();
PrimitiveTypes.Add(id, name);
}
uint containerTypeCount = stream.ReadUInt32();
for (uint i = 0; i < containerTypeCount; i++)
{
UInt16 stringLength = stream.ReadUInt16();
string name = stream.ReadAsciiString(stringLength);
byte id = stream.ReadUInt8();
ContainerTypes.Add(id, name);
}
for (uint i = 0; i < Header.NumContainers; i++)
{
Container container = new Container(stream);
Containers.Add(container);
}
}
bool IsShpTS(Stream s)
{
var start = s.Position;
// First word is zero
if (s.ReadUInt16() != 0)
{
s.Position = start;
return false;
}
// Sanity Check the image count
s.Position += 4;
var imageCount = s.ReadUInt16();
if (s.Position + 24 * imageCount > s.Length)
{
s.Position = start;
return false;
}
// Check the size and format flag
// Some files define bogus frames, so loop until we find a valid one
s.Position += 4;
ushort w, h, f = 0;
byte type;
do
{
w = s.ReadUInt16();
h = s.ReadUInt16();
type = s.ReadUInt8();
}
while (w == 0 && h == 0 && f++ < imageCount);
s.Position = start;
return type < 4;
}
void ParseFile(Stream s, string dirName)
{
s.Position += 7;
var compressedSize = s.ReadUInt32();
s.Position += 12;
var chunkSize = s.ReadUInt16();
s.Position += 4;
var nameLength = s.ReadByte();
var fileName = dirName + "\\" + s.ReadASCII(nameLength);
// Use index syntax to overwrite any duplicate entries with the last value
index[fileName] = new Entry(accumulatedData, compressedSize);
accumulatedData += compressedSize;
// Skip to the end of the chunk
s.Position += chunkSize - nameLength - 30;
}
public ValueSerializer GetDeserializerByManifest([NotNull] Stream stream, [NotNull] DeserializerSession session)
{
var first = stream.ReadByte();
if (first <= 250)
{
return(_deserializerLookup[first]);
}
switch (first)
{
case ConsistentArraySerializer.Manifest:
return(ConsistentArraySerializer.Instance);
case ObjectReferenceSerializer.Manifest:
return(ObjectReferenceSerializer.Instance);
case ObjectSerializer.ManifestFull:
{
var type = TypeEx.GetTypeFromManifestFull(stream, session);
return(GetCustomDeserializer(type));
}
case ObjectSerializer.ManifestVersion:
{
var type = TypeEx.GetTypeFromManifestVersion(stream, session);
return(GetCustomDeserializer(type));
}
case ObjectSerializer.ManifestIndex:
{
var typeId = (int)stream.ReadUInt16(session);
if (typeId < _knownValueSerializers.Length)
{
return(_knownValueSerializers[typeId]);
}
var type = TypeEx.GetTypeFromManifestIndex(typeId, session);
return(GetCustomDeserializer(type));
}
default:
throw new NotSupportedException("Unknown manifest value");
}
}
bool IsWsa(Stream s)
{
var start = s.Position;
var frames = s.ReadUInt16();
if (frames <= 1) // TODO: find a better way to differentiate .shp icons
{
return(false);
}
var x = s.ReadUInt16();
var y = s.ReadUInt16();
var width = s.ReadUInt16();
var height = s.ReadUInt16();
if (width <= 0 || height <= 0)
{
return(false);
}
var delta = s.ReadUInt16() + 37;
var flags = s.ReadUInt16();
var offsets = new uint[frames + 2];
for (var i = 0; i < offsets.Length; i++)
{
offsets[i] = s.ReadUInt32();
}
if (flags == 1)
{
var palette = StreamExts.ReadBytes(s, 768);
for (var i = 0; i < offsets.Length; i++)
{
offsets[i] += 768;
}
}
s.Position = start;
return(s.Length == offsets.Last());
}
public void Read(Stream stream)
{
var magic = new byte[MAGIC.Length];
stream.Read(magic);
if (!MAGIC.SequenceEqual(magic))
{
throw new BadImageFormatException($"Magic value ({magic.ToByteString()}) is not present for a PE32 header");
}
mMajorLinkerVersion = (byte)stream.ReadByte();
mMinorLinkerVersion = (byte)stream.ReadByte();
mSizeOfCode = stream.ReadUInt32();
mSizeOfInitializedData = stream.ReadUInt32();
mSizeOfUninitializedData = stream.ReadUInt32();
mAddressOfEntryPoint = stream.ReadUInt32();
mBaseOfCode = stream.ReadUInt32();
mBaseOfData = stream.ReadUInt32();
mImageBase = stream.ReadUInt32();
mSectionAlignment = stream.ReadUInt32();
mFileAlignment = stream.ReadUInt32();
mMajorOperatingSystemVersion = stream.ReadUInt16();
mMinorOperatingSystemVersion = stream.ReadUInt16();
mMajorImageVersion = stream.ReadUInt16();
mMinorImageVersion = stream.ReadUInt16();
mMajorSubsystemVersion = stream.ReadUInt16();
mMinorSubsystemVersion = stream.ReadUInt16();
mWin32VersionValue = stream.ReadUInt32();
mSizeOfImage = stream.ReadUInt32();
mSizeOfHeaders = stream.ReadUInt32();
mCheckSum = stream.ReadUInt32();
mSubsystem = stream.ReadUInt16();
mDllCharacteristics = stream.ReadUInt16();
mSizeOfStackReserve = stream.ReadUInt32();
mSizeOfStackCommit = stream.ReadUInt32();
mSizeOfHeapReserve = stream.ReadUInt32();
mSizeOfHeapCommit = stream.ReadUInt32();
mLoaderFlags = stream.ReadUInt32();
mNumberOfRvaAndSizes = stream.ReadUInt32();
}
public ShpTSReader(Stream stream)
{
stream.ReadUInt16();
var width = stream.ReadUInt16();
var height = stream.ReadUInt16();
var size = new Size(width, height);
var frameCount = stream.ReadUInt16();
for (var i = 0; i < frameCount; i++)
frames.Add(new FrameHeader(stream, size));
for (var i = 0; i < frameCount; i++)
{
var f = frames[i];
if (f.FileOffset == 0)
continue;
stream.Position = f.FileOffset;
// Uncompressed
if (f.Format == 1 || f.Format == 0)
f.Data = stream.ReadBytes(f.Size.Width * f.Size.Height);
// Uncompressed scanlines
else if (f.Format == 2)
{
f.Data = new byte[f.Size.Width * f.Size.Height];
for (var j = 0; j < f.Size.Height; j++)
{
var length = stream.ReadUInt16() - 2;
stream.Read(f.Data, f.Size.Width * j, length);
}
}
// RLE-zero compressed scanlines
else if (f.Format == 3)
{
f.Data = new byte[f.Size.Width * f.Size.Height];
for (var j = 0; j < f.Size.Height; j++)
{
var length = stream.ReadUInt16() - 2;
Format2.DecodeInto(stream.ReadBytes(length), f.Data, j * f.Size.Width);
}
}
}
spriteFrames = Exts.Lazy(() => frames.Cast<ISpriteFrame>());
}
/// <summary>
/// 读取一个表示数据长度的数据
/// </summary>
/// <param name="stream">从中读取的流</param>
/// <returns>返回读取到的长度信息数据</returns>
/// <exception cref="InvalidDataException">当遇到文件流的末尾时引发</exception>
public static int ReadLengthData(this Stream stream)
{
var len = stream.ReadByte();
if (len < 0)
{
throw new InvalidDataException("遇到文件尾");
}
if (len == 254)
{
len = stream.ReadUInt16();
}
else if (len == 255)
{
len = stream.ReadInt32();
}
return(len);
}
public static float SoundLength(Stream s)
{
var sampleRate = s.ReadUInt16();
/*var dataSize = */ s.ReadInt32();
var outputSize = s.ReadInt32();
var flags = (SoundFlags)s.ReadByte();
var samples = outputSize;
if (0 != (flags & SoundFlags.Stereo))
{
samples /= 2;
}
if (0 != (flags & SoundFlags._16Bit))
{
samples /= 2;
}
return(samples / sampleRate);
}
private static object ReadPrimitiveData(Stream s, SerializeTypeEnum type)
{
switch (type)
{
case SerializeTypeEnum.Bool:
return(s.ReadBool());
case SerializeTypeEnum.Byte:
return((byte)s.ReadByte());
case SerializeTypeEnum.Double:
return(s.ReadDouble());
case SerializeTypeEnum.Float:
return(s.ReadFloat());
case SerializeTypeEnum.Int16:
return(s.ReadInt16());
case SerializeTypeEnum.Int32:
return(s.ReadInt32());
case SerializeTypeEnum.Int64:
return(s.ReadInt64());
case SerializeTypeEnum.UInt16:
return(s.ReadUInt16());
case SerializeTypeEnum.UInt32:
return(s.ReadUInt32());
case SerializeTypeEnum.UInt64:
return(s.ReadUInt64());
case SerializeTypeEnum.String:
return(s.ReadString(Encoding.ASCII));
default:
throw new Exception();
}
}
public void CopyTo(Stream output, Action <int> onProgress)
{
if (file.Flags.HasFlag(CABFlags.FileCompressed))
{
var inf = new Inflater(true);
var buffer = new byte[165535];
do
{
var bytesToExtract = currentVolume.ReadUInt16();
remainingInArchive -= 2;
toExtract -= 2;
inf.SetInput(GetBytes(bytesToExtract));
toExtract -= bytesToExtract;
while (!inf.IsNeedingInput)
{
if (onProgress != null)
{
onProgress((int)(100 * output.Position / file.ExpandedSize));
}
var inflated = inf.Inflate(buffer);
output.Write(buffer, 0, inflated);
}
inf.Reset();
} while (toExtract > 0);
}
else
{
do
{
if (onProgress != null)
{
onProgress((int)(100 * output.Position / file.ExpandedSize));
}
toExtract -= remainingInArchive;
output.Write(GetBytes(remainingInArchive), 0, (int)remainingInArchive);
} while (toExtract > 0);
}
}
public VoiceTable(Stream s, EndianUtils.Endianness e = EndianUtils.Endianness.LittleEndian)
{
s.Position = 0;
ushort count = s.ReadUInt16(e);
if (s.PeekUInt32(e) == 1)
{
// CS2 has something odd I don't fully understand at the start of the file, try to skip past that
UnknownStartOfFileData = s.ReadUInt8Array(0xe);
}
else
{
UnknownStartOfFileData = null;
}
Entries = new List <VoiceTableEntry>();
for (int i = 0; i < count; ++i)
{
Entries.Add(new VoiceTableEntry(s, e));
}
}
public static bool LoadSound(Stream s, out Func <Stream> result, out int sampleRate, out int sampleBits, out int channels)
{
result = null;
var startPosition = s.Position;
try
{
sampleRate = s.ReadUInt16();
var dataSize = s.ReadInt32();
var outputSize = s.ReadInt32();
var readFlag = s.ReadByte();
sampleBits = (readFlag & (int)SoundFlags._16Bit) == 0 ? 8 : 16;
channels = (readFlag & (int)SoundFlags.Stereo) == 0 ? 1 : 2;
var readFormat = s.ReadByte();
if (!Enum.IsDefined(typeof(SoundFormat), readFormat))
{
return(false);
}
if (readFormat == (int)SoundFormat.WestwoodCompressed)
{
throw new NotImplementedException();
}
var offsetPosition = s.Position;
result = () =>
{
var audioStream = SegmentStream.CreateWithoutOwningStream(s, offsetPosition, (int)(s.Length - offsetPosition));
return(new AudStream(audioStream, outputSize, dataSize));
};
}
finally
{
s.Position = startPosition;
}
return(true);
}
void SkipProperty()
{
uint raw = Stream.ReadUInt8();
var type = (SirenTypeId)(raw & 0x1f);
raw >>= 5;
if (raw < 6)
{
}
else if (raw == 6)
{
Stream.ReadUInt8();
}
else
{
Stream.ReadUInt16();
}
SkipPropertyHelper(type);
}
public void ApplyPatch(long offset, ulong value, ulong mask, byte patchSize, Endianness endianness)
{
try
{
Stream.Position = offset;
ulong current = 0;
switch (patchSize)
{
case 8: current = (ulong)Stream.ReadByte(); break;
case 16: current = (ulong)Stream.ReadUInt16(endianness); break;
case 32: current = (ulong)Stream.ReadUInt32(endianness); break;
case 64: current = (ulong)Stream.ReadUInt64(endianness); break;
}
Stream.Position = offset;
current = (current & ~mask) | value;
// Apply the patch
switch (patchSize)
{
case 8: Stream.WriteByte((byte)current); break;
case 16: Stream.Write((ushort)current, endianness); break;
case 32: Stream.Write((uint)current, endianness); break;
case 64: Stream.Write((ulong)current, endianness); break;
}
}
catch (Exception ex)
{
return;
}
}
public static byte[] LoadSound(Stream s)
{
/*var sampleRate =*/ s.ReadUInt16();
var dataSize = s.ReadInt32();
var outputSize = s.ReadInt32();
/*var flags = (SoundFlags)*/ s.ReadByte();
/*var format = (SoundFormat)*/ s.ReadByte();
var output = new byte[outputSize];
var offset = 0;
var index = 0;
var currentSample = 0;
while (dataSize > 0)
{
var chunk = Chunk.Read(s);
for (var n = 0; n < chunk.CompressedSize; n++)
{
var b = s.ReadUInt8();
var t = DecodeSample(b, ref index, ref currentSample);
output[offset++] = (byte)t;
output[offset++] = (byte)(t >> 8);
if (offset < outputSize)
{
/* possible that only half of the final byte is used! */
t = DecodeSample((byte)(b >> 4), ref index, ref currentSample);
output[offset++] = (byte)t;
output[offset++] = (byte)(t >> 8);
}
}
dataSize -= 8 + chunk.CompressedSize;
}
return(output);
}
private static bool LoadAppendMenu_old(HMENU hMenuParent, Stream stream)
{
// Read flags
ushort flags = (ushort)stream.ReadByte();
if ((flags & MF_POPUP) == 0)
{
// Regular menu item
ushort id = stream.ReadUInt16();
string text = stream.ReadNullTerminatedString();
if (text.StartsWith("\u0008"))
{
flags |= MF_HELP;
text = text.Substring(1);
}
if (string.IsNullOrEmpty(text))
{
text = null;
}
User.AppendMenu(hMenuParent, (uint)(flags & ~(MF_END | MF_BITMAP)), (IntPtr)id, text);
}
else
{
// Popup menu item
string text = stream.ReadNullTerminatedString();
// Load all items
var popup = User.CreatePopupMenu();
while (LoadAppendMenu_old(popup, stream))
{
;
}
// Add it
User.AppendMenu(hMenuParent, (uint)(flags & ~MF_END), popup.value, text);
}
return((flags & MF_END) == 0);
}
public ValueSerializer GetDeserializerByManifest(Stream stream, DeserializerSession session)
{
//magic byte, a homage to Apache Kafka
var magicByte = stream.ReadByte();
if (magicByte <= 250)
{
return(_deserializerLookup[magicByte]);
}
switch (magicByte)
{
case ConsistentArraySerializer.Manifest:
return(ConsistentArraySerializer.Instance);
case ObjectReferenceSerializer.Manifest:
return(ObjectReferenceSerializer.Instance);
case ObjectSerializer.ManifestFull:
{
var type = TypeEx.GetTypeFromManifestFull(stream, session);
return(GetCustomDeserializer(type));
}
case ObjectSerializer.ManifestIndex:
{
var typeId = (int)stream.ReadUInt16(session);
if (typeId < _knownValueSerializers.Length)
{
return(_knownValueSerializers[typeId]);
}
var type = TypeEx.GetTypeFromManifestIndex(typeId, session);
return(GetCustomDeserializer(type));
}
default:
throw new NotSupportedException("Unknown manifest value");
}
}
public static bool LoadSound(Stream s, out Func <Stream> result, out int sampleRate)
{
result = null;
var startPosition = s.Position;
try
{
sampleRate = s.ReadUInt16();
var dataSize = s.ReadInt32();
var outputSize = s.ReadInt32();
var readFlag = s.ReadByte();
if (!Enum.IsDefined(typeof(SoundFlags), readFlag))
{
return(false);
}
var readFormat = s.ReadByte();
if (!Enum.IsDefined(typeof(SoundFormat), readFormat))
{
return(false);
}
var offsetPosition = s.Position;
result = () =>
{
var audioStream = SegmentStream.CreateWithoutOwningStream(s, offsetPosition, (int)(s.Length - offsetPosition));
return(new AudStream(audioStream, outputSize, dataSize));
};
}
finally
{
s.Position = startPosition;
}
return(true);
}
static bool IsShpTD(Stream s)
{
var start = s.Position;
// First word is the image count
var imageCount = s.ReadUInt16();
if (imageCount == 0)
{
s.Position = start;
return(false);
}
// Last offset should point to the end of file
var finalOffset = start + 14 + 8 * imageCount;
if (finalOffset > s.Length)
{
s.Position = start;
return(false);
}
s.Position = finalOffset;
var eof = s.ReadUInt32();
if (eof != s.Length)
{
s.Position = start;
return(false);
}
// Check the format flag on the first frame
s.Position = start + 17;
var b = s.ReadUInt8();
s.Position = start;
return(b == 0x20 || b == 0x40 || b == 0x80);
}
public Blit(Stream stream)
{
this.Frames = new BlitFrame[stream.ReadInt32()];
var frameOffsets = new int[this.Frames.Length];
stream.ReadInt32(); // TODO Unk
var paletteOffset = stream.ReadInt32();
var identifier = new string(stream.ReadASCII(4).Reverse().ToArray());
if (identifier != "BLT8")
{
throw new("Unknown blit type.");
}
for (var i = 0; i < this.Frames.Length; i++)
{
frameOffsets[i] = stream.ReadInt32();
}
stream.Position = paletteOffset;
var palette = new byte[256 * 4];
for (var i = 0; i < palette.Length;)
{
var color16 = stream.ReadUInt16();
palette[i++] = (byte)(((color16 & 0x001f) << 3) & 0xff);
palette[i++] = (byte)(((color16 & 0x03e0) >> 2) & 0xff);
palette[i++] = (byte)(((color16 & 0x7c00) >> 7) & 0xff);
palette[i++] = 0xff;
}
for (var i = 0; i < this.Frames.Length; i++)
{
stream.Position = frameOffsets[i];
this.Frames[i] = new(stream, palette);
}
}
private static Stream ReadLocalFile(Stream reader, out String fileName, out UInt32 decompressedSize, out UInt16 compressionMethod)
{
/*UInt16 version =*/
reader.ReadUInt16();
/*UInt16 bitflags =*/
reader.ReadUInt16();
compressionMethod = reader.ReadUInt16();
if (compressionMethod != DeflateCompression && compressionMethod != StoreCompression)
{
throw new Exception("Invalid compression method " + compressionMethod);
}
/*UInt16 modtime =*/
reader.ReadUInt16();
/*UInt16 createtime =*/
reader.ReadUInt16();
/*UInt32 crc =*/
reader.ReadUInt32();
UInt32 compressedSize = reader.ReadUInt32();
decompressedSize = reader.ReadUInt32();
UInt16 nameLength = reader.ReadUInt16();
UInt16 fieldLength = reader.ReadUInt16();
byte[] name = new byte[nameLength];
reader.Read(name, 0, nameLength);
/*byte[] fields =*/
reader.Seek(fieldLength, SeekOrigin.Current);
fileName = Encoding.UTF8.GetString(name);
MemoryStream ms = new MemoryStream((int)compressedSize);
CopyTo(reader, ms, compressedSize);
ms.Position = 0;
return(ms);
}
public Vbc(Stream stream)
{
if (stream.ReadASCII(4) != "SIFF")
{
throw new InvalidDataException("Invalid vbc (invalid SIFF section)");
}
stream.ReadUInt32(); // Length
if (stream.ReadASCII(4) != "VBV1")
{
throw new InvalidDataException("Invalid vbc (not VBV1)");
}
if (stream.ReadASCII(4) != "VBHD")
{
throw new InvalidDataException("Invalid vbc (not VBHD)");
}
stream.ReadUInt32(); // Length
stream.ReadUInt16(); // Version
Size = new int2(stream.ReadUInt16(), stream.ReadUInt16());
stream.ReadUInt32(); // 0
Frames = stream.ReadUInt16();
SampleBits = stream.ReadUInt16();
SampleRate = stream.ReadUInt16();
stream.ReadUInt32(); // 0
stream.ReadUInt32(); // 0
stream.ReadUInt32(); // 0
stream.ReadUInt32(); // 0
if (stream.ReadASCII(4) != "BODY")
{
throw new InvalidDataException("Invalid vbc (not BODY)");
}
stream.ReadUInt32(); // Length
frames = new VbcFrame[Frames];
for (var i = 0; i < Frames; i++)
{
frames[i] = new VbcFrame(stream);
}
}
public object Deserialize(GraphicsDevice device, Stream stream, string fileName)
{
var spriteSheet = new AnimatedSpriteSheet();
var version = stream.ReadByte();
spriteSheet.Name = stream.ReadStringWithLength();
spriteSheet.AssetName = stream.ReadStringWithLength();
spriteSheet.StartDelay = stream.ReadInt64();
spriteSheet.TimeBetweenSprites = stream.ReadInt64();
spriteSheet.Repeat = stream.ReadBool();
spriteSheet.ReverseAtEnd = stream.ReadBool();
ushort frameCount = stream.ReadUInt16();
for (int i = 0; i < frameCount; i++)
{
Sprite sprite = new Sprite();
stream.ReadUInt16(); // Frame index, unused
sprite.Name = stream.ReadStringWithLength();
sprite.Width = stream.ReadUInt16();
sprite.Height = stream.ReadUInt16();
sprite.X = stream.ReadUInt16();
sprite.Y = stream.ReadUInt16();
spriteSheet.Sprites[sprite.Name] = sprite;
}
using (var fs = new FileStream(Path.Combine(Path.GetDirectoryName(fileName), spriteSheet.AssetName + ".png"), FileMode.Open))
{
spriteSheet.Texture = Texture2D.FromStream(device, fs);
}
foreach (var sprite in spriteSheet.Sprites)
{
sprite.Value.Texture = spriteSheet.Texture;
}
return(spriteSheet);
}
public void Read(Stream stream)
{
var magic = new byte[MAGIC.Length];
stream.Read(magic);
if (!MAGIC.SequenceEqual(magic))
{
throw new BadImageFormatException("Magic value is not present for an ELF file");
}
EI_CLASS = stream.ReadByteAndParse <HeaderIdentityClass>(HeaderIdentityClass.ELFCLASSNONE);
EI_DATA = stream.ReadByteAndParse <HeaderIdentityData>(HeaderIdentityData.ELFDATANONE);
EI_VERSION = stream.ReadByteAndParse <HeaderIdentityVersion>(HeaderIdentityVersion.EI_CURRENT);
EI_OSABI = stream.ReadByteAndParse <HeaderOsAbiVersion>(HeaderOsAbiVersion.ELFOSABI_NONE);
EI_ABIVERSION = (byte)stream.ReadByte();
stream.Seek(16, SeekOrigin.Begin);
E_TYPE = stream.ReadHalfWord <HeaderType>(HeaderType.ET_NONE);
E_MACHINE = stream.ReadHalfWord <HeaderMachine>(HeaderMachine.EM_NONE);
E_VERSION = stream.ReadWord <HeaderVersion>(HeaderVersion.EV_NONE);
E_ENTRY = stream.ReadAddress32();
E_PHOFF = stream.ReadOffset32();
E_SHOFF = stream.ReadOffset32();
E_FLAGS = stream.ReadUInt32();
E_EHSIZE = stream.ReadUInt16();
E_PHENTSIZE = stream.ReadUInt16();
E_PHNUM = stream.ReadUInt16();
E_SHENTSIZE = stream.ReadUInt16();
E_SHNUM = stream.ReadUInt16();
E_SHSTRNDX = stream.ReadUInt16();
if (E_EHSIZE != stream.Position && E_EHSIZE != 64)
{
throw new InvalidOperationException("E_EHSIZE does not equal the current reader position");
}
}
/// <summary>
/// Reads an object from a stream.
/// </summary>
/// <param name="stream">Source stream.</param>
/// <returns>Decoded object.</returns>
public static object ReadObject(this Stream stream)
{
ObjectType type = (ObjectType)stream.ReadNextByte();
switch (type)
{
case ObjectType.Null:
return(null);
case ObjectType.DBNull:
return(DBNull.Value);
case ObjectType.BooleanTrue:
return(true);
case ObjectType.BooleanFalse:
return(false);
case ObjectType.Char:
return(stream.ReadChar());
case ObjectType.SByte:
return(stream.ReadSByte());
case ObjectType.Byte:
return(stream.ReadNextByte());
case ObjectType.Int16:
return(stream.ReadInt16());
case ObjectType.UInt16:
return(stream.ReadUInt16());
case ObjectType.Int32:
return(stream.ReadInt32());
case ObjectType.UInt32:
return(stream.ReadUInt32());
case ObjectType.Int64:
return(stream.ReadInt64());
case ObjectType.UInt64:
return(stream.ReadUInt64());
case ObjectType.Single:
return(stream.ReadSingle());
case ObjectType.Double:
return(stream.ReadDouble());
case ObjectType.Decimal:
return(stream.ReadDecimal());
case ObjectType.DateTime:
return(stream.ReadDateTime());
case ObjectType.String:
return(stream.ReadString());
case ObjectType.ByteArray:
return(stream.ReadBytes());
case ObjectType.CharArray:
return(stream.ReadString().ToCharArray());
case ObjectType.Guid:
return(stream.ReadGuid());
default:
throw new ArgumentOutOfRangeException();
}
}
private static uint ReadUInt32(this Stream stream)
{
return(unchecked ((uint)((uint)stream.ReadUInt16() | ((uint)stream.ReadUInt16() << 16))));
}
private static short ReadInt16(this Stream stream)
{
return(unchecked ((short)stream.ReadUInt16()));
}
public static byte[] LoadSound(Stream s)
{
/*var sampleRate =*/ s.ReadUInt16();
var dataSize = s.ReadInt32();
var outputSize = s.ReadInt32();
/*var flags = (SoundFlags)*/ s.ReadByte();
/*var format = (SoundFormat)*/ s.ReadByte();
var output = new byte[outputSize];
var offset = 0;
var index = 0;
var currentSample = 0;
while (dataSize > 0)
{
var chunk = Chunk.Read(s);
for (int n = 0; n < chunk.CompressedSize; n++)
{
var b = s.ReadUInt8();
var t = DecodeSample(b, ref index, ref currentSample);
output[offset++] = (byte)t;
output[offset++] = (byte)(t >> 8);
if (offset < outputSize)
{
/* possible that only half of the final byte is used! */
t = DecodeSample((byte)(b >> 4), ref index, ref currentSample);
output[offset++] = (byte)t;
output[offset++] = (byte)(t >> 8);
}
}
dataSize -= 8 + chunk.CompressedSize;
}
return output;
}
public byte WindowsSDKVersion; // 3F Windows SDK version number
public static IMAGE_OS2_HEADER Deserialize(Stream stream)
{
var ioh = new IMAGE_OS2_HEADER();
ioh.Magic = stream.ReadUInt16();
ioh.LinkerVersion = stream.ReadByteValue();
ioh.LinkerRevision = stream.ReadByteValue();
ioh.EntryTableOffset = stream.ReadUInt16();
ioh.EntryTableSize = stream.ReadUInt16();
ioh.CrcChecksum = stream.ReadUInt32();
ioh.Flags = stream.ReadUInt16();
ioh.Autodata = stream.ReadUInt16();
ioh.InitialHeapAlloc = stream.ReadUInt16();
ioh.InitialStackAlloc = stream.ReadUInt16();
ioh.InitialCSIPSetting = stream.ReadUInt32();
ioh.InitialSSSPSetting = stream.ReadUInt32();
ioh.FileSegmentCount = stream.ReadUInt16();
ioh.ModuleReferenceTableSize = stream.ReadUInt16();
ioh.NonResidentNameTableSize = stream.ReadUInt16();
ioh.SegmentTableOffset = stream.ReadUInt16();
ioh.ResourceTableOffset = stream.ReadUInt16();
ioh.ResidentNameTableOffset = stream.ReadUInt16();
ioh.ModuleReferenceTableOffset = stream.ReadUInt16();
ioh.ImportedNamesTableOffset = stream.ReadUInt16();
ioh.NonResidentNamesTableOffset = stream.ReadUInt32();
ioh.MovableEntriesCount = stream.ReadUInt16();
ioh.SegmentAlignmentShiftCount = stream.ReadUInt16();
ioh.ResourceEntriesCount = stream.ReadUInt16();
ioh.TargetOperatingSystem = stream.ReadByteValue();
ioh.AdditionalFlags = stream.ReadByteValue();
ioh.Reserved = new ushort[Constants.NERESWORDS];
for (int i = 0; i < Constants.NERESWORDS; i++)
{
ioh.Reserved[i] = stream.ReadUInt16();
}
ioh.WindowsSDKRevision = stream.ReadByteValue();
ioh.WindowsSDKVersion = stream.ReadByteValue();
return(ioh);
}
public FileDescriptor(Stream stream, uint index, long tableOffset)
{
Index = index;
Flags = (CABFlags)stream.ReadUInt16();
ExpandedSize = stream.ReadUInt32();
stream.Position += 4;
CompressedSize = stream.ReadUInt32();
stream.Position += 4;
DataOffset = stream.ReadUInt32();
stream.Position += 4;
MD5 = stream.ReadBytes(16);
stream.Position += 16;
NameOffset = stream.ReadUInt32();
DirectoryIndex = stream.ReadUInt16();
stream.Position += 12;
LinkToPrevious = stream.ReadUInt32();
LinkToNext = stream.ReadUInt32();
LinkFlags = (LinkFlags)stream.ReadUInt8();
Volume = stream.ReadUInt16();
var pos = stream.Position;
stream.Position = tableOffset + NameOffset;
Filename = stream.ReadASCIIZ();
stream.Position = pos;
}
public FileDescriptor(Stream reader, long tableOffset)
{
Flags = reader.ReadUInt16();
ExpandedSize = reader.ReadUInt32();
/* unknown */ reader.ReadUInt32();
CompressedSize = reader.ReadUInt32();
/* unknown */ reader.ReadUInt32();
DataOffset = reader.ReadUInt32();
/* unknown */ reader.ReadUInt32();
MD5 = reader.ReadBytes(16);
/* unknown */ reader.ReadBytes(16);
NameOffset = reader.ReadUInt32();
DirectoryIndex = reader.ReadUInt16();
/* unknown */ reader.ReadBytes(12);
LinkToPrevious = reader.ReadUInt32();
LinkToNext = reader.ReadUInt32();
LinkFlags = reader.ReadBytes(1)[0];
Volume = reader.ReadUInt16();
var posSave = reader.Position;
reader.Seek(tableOffset + NameOffset, SeekOrigin.Begin);
Filename = reader.ReadASCIIZ();
reader.Seek(posSave, SeekOrigin.Begin);
}
public ShpTSFrame(Stream s, Size frameSize)
{
var x = s.ReadUInt16();
var y = s.ReadUInt16();
var width = s.ReadUInt16();
var height = s.ReadUInt16();
// Pad the dimensions to an even number to avoid issues with half-integer offsets
var dataWidth = width;
var dataHeight = height;
if (dataWidth % 2 == 1)
{
dataWidth += 1;
}
if (dataHeight % 2 == 1)
{
dataHeight += 1;
}
Offset = new int2(x + (dataWidth - frameSize.Width) / 2, y + (dataHeight - frameSize.Height) / 2);
Size = new Size(dataWidth, dataHeight);
FrameSize = frameSize;
Format = s.ReadUInt8();
s.Position += 11;
FileOffset = s.ReadUInt32();
if (FileOffset == 0)
{
return;
}
// Parse the frame data as we go (but remember to jump back to the header before returning!)
var start = s.Position;
s.Position = FileOffset;
Data = new byte[dataWidth * dataHeight];
if (Format == 3)
{
// Format 3 provides RLE-zero compressed scanlines
for (var j = 0; j < height; j++)
{
var length = s.ReadUInt16() - 2;
RLEZerosCompression.DecodeInto(s.ReadBytes(length), Data, dataWidth * j);
}
}
else
{
// Format 2 provides uncompressed length-prefixed scanlines
// Formats 1 and 0 provide an uncompressed full-width row
var length = Format == 2 ? s.ReadUInt16() - 2 : width;
for (var j = 0; j < height; j++)
{
s.ReadBytes(Data, dataWidth * j, length);
}
}
s.Position = start;
}
public VqaReader(Stream stream)
{
this.stream = stream;
// Decode FORM chunk
if (stream.ReadASCII(4) != "FORM")
{
throw new InvalidDataException("Invalid vqa (invalid FORM section)");
}
/*var length = */ stream.ReadUInt32();
if (stream.ReadASCII(8) != "WVQAVQHD")
{
throw new InvalidDataException("Invalid vqa (not WVQAVQHD)");
}
/*var length2 = */ stream.ReadUInt32();
/*var version = */ stream.ReadUInt16();
videoFlags = stream.ReadUInt16();
Frames = stream.ReadUInt16();
Width = stream.ReadUInt16();
Height = stream.ReadUInt16();
blockWidth = stream.ReadUInt8();
blockHeight = stream.ReadUInt8();
Framerate = stream.ReadUInt8();
chunkBufferParts = stream.ReadUInt8();
blocks = new int2(Width / blockWidth, Height / blockHeight);
numColors = stream.ReadUInt16();
/*var maxBlocks = */ stream.ReadUInt16();
/*var unknown1 = */ stream.ReadUInt16();
/*var unknown2 = */ stream.ReadUInt32();
// Audio
sampleRate = stream.ReadUInt16();
audioChannels = stream.ReadByte();
sampleBits = stream.ReadByte();
/*var unknown3 =*/ stream.ReadUInt32();
/*var unknown4 =*/ stream.ReadUInt16();
/*maxCbfzSize =*/ stream.ReadUInt32(); // Unreliable
/*var unknown5 =*/ stream.ReadUInt32();
var frameSize = Exts.NextPowerOf2(Math.Max(Width, Height));
if (IsHqVqa)
{
cbfBuffer = new byte[maxCbfzSize];
cbf = new byte[maxCbfzSize * 3];
origData = new byte[maxCbfzSize];
}
else
{
cbfBuffer = new byte[Width * Height];
cbf = new byte[Width * Height];
cbp = new byte[Width * Height];
origData = new byte[2 * blocks.X * blocks.Y];
}
palette = new uint[numColors];
frameData = new uint[frameSize, frameSize];
var type = stream.ReadASCII(4);
while (type != "FINF")
{
// Sub type is a file tag
if (type[3] == 'F')
{
var jmp = int2.Swap(stream.ReadUInt32());
stream.Seek(jmp, SeekOrigin.Current);
type = stream.ReadASCII(4);
}
else
{
throw new NotSupportedException("Vqa uses unknown Subtype: {0}".F(type));
}
}
/*var length = */ stream.ReadUInt16();
/*var unknown4 = */ stream.ReadUInt16();
// Frame offsets
offsets = new uint[Frames];
for (var i = 0; i < Frames; i++)
{
offsets[i] = stream.ReadUInt32();
if (offsets[i] > 0x40000000)
{
offsets[i] -= 0x40000000;
}
offsets[i] <<= 1;
}
CollectAudioData();
Reset();
}
static void Preload(Stream stream, out VocBlock[] blocks, out int totalSamples, out int sampleRate)
{
var blockList = new List <VocBlock>();
totalSamples = 0;
sampleRate = 0;
while (true)
{
var block = default(VocBlock);
try
{
block.Code = stream.ReadByte();
block.Length = 0;
}
catch (EndOfStreamException)
{
// Stream is allowed to end without a last block
break;
}
if (block.Code == 0 || block.Code > 9)
{
break;
}
block.Length = stream.ReadByte();
block.Length |= stream.ReadByte() << 8;
block.Length |= stream.ReadByte() << 16;
var skip = 0;
switch (block.Code)
{
// Sound data
case 1:
{
if (block.Length < 2)
{
throw new InvalidDataException("Invalid sound data block length in voc file");
}
var freqDiv = stream.ReadByte();
block.SampleBlock.Rate = GetSampleRateFromVocRate(freqDiv);
var codec = stream.ReadByte();
if (codec != 0)
{
throw new InvalidDataException("Unhandled codec used in voc file");
}
skip = block.Length - 2;
block.SampleBlock.Samples = skip;
block.SampleBlock.Offset = stream.Position;
// See if last block contained additional information
if (blockList.Count > 0)
{
var b = blockList.Last();
if (b.Code == 8)
{
block.SampleBlock.Rate = b.SampleBlock.Rate;
blockList.Remove(b);
}
}
sampleRate = Math.Max(sampleRate, block.SampleBlock.Rate);
break;
}
// Silence
case 3:
{
if (block.Length != 3)
{
throw new InvalidDataException("Invalid silence block length in voc file");
}
block.SampleBlock.Offset = 0;
block.SampleBlock.Samples = stream.ReadUInt16() + 1;
var freqDiv = stream.ReadByte();
block.SampleBlock.Rate = GetSampleRateFromVocRate(freqDiv);
break;
}
// Repeat start
case 6:
{
if (block.Length != 2)
{
throw new InvalidDataException("Invalid repeat start block length in voc file");
}
block.LoopBlock.Count = stream.ReadUInt16() + 1;
break;
}
// Repeat end
case 7:
break;
// Extra info
case 8:
{
if (block.Length != 4)
{
throw new InvalidDataException("Invalid info block length in voc file");
}
int freqDiv = stream.ReadUInt16();
if (freqDiv == 65536)
{
throw new InvalidDataException("Invalid frequency divisor 65536 in voc file");
}
var codec = stream.ReadByte();
if (codec != 0)
{
throw new InvalidDataException("Unhandled codec used in voc file");
}
var channels = stream.ReadByte() + 1;
if (channels != 1)
{
throw new InvalidDataException("Unhandled number of channels in voc file");
}
block.SampleBlock.Offset = 0;
block.SampleBlock.Samples = 0;
block.SampleBlock.Rate = (int)(256000000L / (65536L - freqDiv));
break;
}
// Sound data (New format)
case 9:
default:
throw new InvalidDataException("Unhandled code in voc file");
}
if (skip > 0)
{
stream.Seek(skip, SeekOrigin.Current);
}
blockList.Add(block);
}
// Check validity and calculated total number of samples
foreach (var b in blockList)
{
if (b.Code == 8)
{
throw new InvalidDataException("Unused block 8 in voc file");
}
if (b.Code != 1 && b.Code != 9)
{
continue;
}
if (b.SampleBlock.Rate != sampleRate)
{
throw new InvalidDataException("Voc file contains chunks with different sample rate");
}
totalSamples += b.SampleBlock.Samples;
}
blocks = blockList.ToArray();
}
public static float SoundLength(Stream s)
{
var sampleRate = s.ReadUInt16();
/*var dataSize = */ s.ReadInt32();
var outputSize = s.ReadInt32();
var flags = (SoundFlags)s.ReadByte();
var samples = outputSize;
if (0 != (flags & SoundFlags.Stereo)) samples /= 2;
if (0 != (flags & SoundFlags._16Bit)) samples /= 2;
return samples / sampleRate;
}
public VqaReader(Stream stream)
{
this.stream = stream;
// Decode FORM chunk
if (stream.ReadASCII(4) != "FORM")
throw new InvalidDataException("Invalid vqa (invalid FORM section)");
/*var length = */ stream.ReadUInt32();
if (stream.ReadASCII(8) != "WVQAVQHD")
throw new InvalidDataException("Invalid vqa (not WVQAVQHD)");
/* var length = */stream.ReadUInt32();
/*var version = */stream.ReadUInt16();
/*var flags = */stream.ReadUInt16();
Frames = stream.ReadUInt16();
Width = stream.ReadUInt16();
Height = stream.ReadUInt16();
blockWidth = stream.ReadUInt8();
blockHeight = stream.ReadUInt8();
Framerate = stream.ReadUInt8();
cbParts = stream.ReadUInt8();
blocks = new int2(Width / blockWidth, Height / blockHeight);
numColors = stream.ReadUInt16();
/*var maxBlocks = */stream.ReadUInt16();
/*var unknown1 = */stream.ReadUInt16();
/*var unknown2 = */stream.ReadUInt32();
// Audio
/*var freq = */stream.ReadUInt16();
/*var channels = */stream.ReadByte();
/*var bits = */stream.ReadByte();
/*var unknown3 = */stream.ReadBytes(14);
var frameSize = Exts.NextPowerOf2(Math.Max(Width, Height));
cbf = new byte[Width*Height];
cbp = new byte[Width*Height];
palette = new uint[numColors];
origData = new byte[2*blocks.X*blocks.Y];
frameData = new uint[frameSize, frameSize];
var type = stream.ReadASCII(4);
if (type != "FINF")
{
stream.Seek(27, SeekOrigin.Current);
type = stream.ReadASCII(4);
}
/*var length = */stream.ReadUInt16();
/*var unknown4 = */stream.ReadUInt16();
// Frame offsets
offsets = new UInt32[Frames];
for (var i = 0; i < Frames; i++)
{
offsets[i] = stream.ReadUInt32();
if (offsets[i] > 0x40000000)
offsets[i] -= 0x40000000;
offsets[i] <<= 1;
}
CollectAudioData();
Reset();
}
ShpD2Frame[] ParseFrames(Stream s)
{
var start = s.Position;
var imageCount = s.ReadUInt16();
// Last offset is pointer to end of file.
var offsets = new uint[imageCount + 1];
var temp = s.ReadUInt32();
// If fourth byte in file is non-zero, the offsets are two bytes each.
var twoByteOffset = (temp & 0xFF0000) > 0;
s.Position = 2;
for (var i = 0; i < imageCount + 1; i++)
offsets[i] = (twoByteOffset ? s.ReadUInt16() : s.ReadUInt32()) + 2;
var frames = new ShpD2Frame[imageCount];
for (var i = 0; i < frames.Length; i++)
{
s.Position = offsets[i];
frames[i] = new ShpD2Frame(s);
}
s.Position = start;
return frames;
}
private void loadHeader(Stream stream)
{
uint tag = stream.ReadUInt32();
if (tag != SfarTag)
{
throw new Exception("Wrong SFAR tag");
}
uint sfarVersion = stream.ReadUInt32();
if (sfarVersion != SfarVersion)
{
throw new Exception("Wrong SFAR version");
}
uint dataOffset = stream.ReadUInt32();
uint entriesOffset = stream.ReadUInt32();
filesCount = stream.ReadUInt32();
uint sizesArrayOffset = stream.ReadUInt32();
maxBlockSize = stream.ReadUInt32();
uint compressionTag = stream.ReadUInt32();
if (compressionTag != LZMATag)
{
throw new Exception("Not LZMA compression for SFAR file");
}
uint numBlockSizes = 0;
stream.JumpTo(entriesOffset);
filesList = new List <FileEntry>();
for (int i = 0; i < filesCount; i++)
{
FileEntry file = new FileEntry();
file.filenameHash = stream.ReadToBuffer(16);
file.compressedBlockSizesIndex = stream.ReadInt32();
file.uncomprSize = stream.ReadUInt32();
file.uncomprSize |= (long)stream.ReadByte() << 32;
file.dataOffset = stream.ReadUInt32();
file.dataOffset |= (long)stream.ReadByte() << 32;
file.numBlocks = (uint)((file.uncomprSize + maxBlockSize - 1) / maxBlockSize);
filesList.Add(file);
numBlockSizes += file.numBlocks;
}
stream.JumpTo(sizesArrayOffset);
blockSizes = new List <ushort>();
for (int i = 0; i < numBlockSizes; i++)
{
blockSizes.Add(stream.ReadUInt16());
}
filenamesIndex = -1;
for (int i = 0; i < filesCount; i++)
{
if (StructuralComparisons.StructuralEqualityComparer.Equals(filesList[i].filenameHash, FileListHash))
{
stream.JumpTo(filesList[i].dataOffset);
int compressedBlockSize = blockSizes[filesList[i].compressedBlockSizesIndex];
byte[] inBuf = stream.ReadToBuffer(compressedBlockSize);
byte[] outBuf = SevenZipHelper.LZMA.Decompress(inBuf, (uint)filesList[i].uncomprSize);
if (outBuf.Length == 0)
{
throw new Exception();
}
StreamReader filenamesStream = new StreamReader(new MemoryStream(outBuf));
while (filenamesStream.EndOfStream == false)
{
string name = filenamesStream.ReadLine();
byte[] hash = MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(name.ToLowerInvariant()));
for (int l = 0; l < filesCount; l++)
{
if (StructuralComparisons.StructuralEqualityComparer.Equals(filesList[l].filenameHash, hash))
{
FileEntry f = filesList[l];
f.filenamePath = name;
filesList[l] = f;
}
}
}
filenamesIndex = i;
break;
}
}
if (filenamesIndex == -1)
{
throw new Exception("filenames entry not found");
}
}
public ShpTSFrame(Stream s, Size frameSize)
{
var x = s.ReadUInt16();
var y = s.ReadUInt16();
var width = s.ReadUInt16();
var height = s.ReadUInt16();
// Pad the dimensions to an even number to avoid issues with half-integer offsets
var dataWidth = width;
var dataHeight = height;
if (dataWidth % 2 == 1)
dataWidth += 1;
if (dataHeight % 2 == 1)
dataHeight += 1;
Offset = new int2(x + (dataWidth - frameSize.Width) / 2, y + (dataHeight - frameSize.Height) / 2);
Size = new Size(dataWidth, dataHeight);
FrameSize = frameSize;
Format = s.ReadUInt8();
s.Position += 11;
FileOffset = s.ReadUInt32();
if (FileOffset == 0)
return;
// Parse the frame data as we go (but remember to jump back to the header before returning!)
var start = s.Position;
s.Position = FileOffset;
Data = new byte[dataWidth * dataHeight];
if (Format == 3)
{
// Format 3 provides RLE-zero compressed scanlines
for (var j = 0; j < height; j++)
{
var length = s.ReadUInt16() - 2;
Format2.DecodeInto(s.ReadBytes(length), Data, dataWidth * j);
}
}
else
{
// Format 2 provides uncompressed length-prefixed scanlines
// Formats 1 and 0 provide an uncompressed full-width row
var length = Format == 2 ? s.ReadUInt16() - 2 : width;
for (var j = 0; j < height; j++)
s.ReadBytes(Data, dataWidth * j, length);
}
s.Position = start;
}
