public Packfile(Stream stream, bool isStr2)
{
IsStr2 = isStr2;
stream.Seek(0, SeekOrigin.Begin);
FileData = stream.ReadStruct<PackfileFileData>();
m_Files = new List<IPackfileEntry>();
uint runningPosition = 0;
List<PackfileEntryFileData> entryFileData = new List<PackfileEntryFileData>();
for (int i = 0; i < FileData.NumFiles; i++)
{
PackfileEntryFileData data = stream.ReadStruct<PackfileEntryFileData>();
if (IsCondensed && IsCompressed)
{
data.Flags = 0;
data.Start = runningPosition;
runningPosition += data.Size;
}
else if (IsCondensed)
{
data.Start = runningPosition;
runningPosition += data.Size.Align(16);
}
entryFileData.Add(data);
}
for (int i = 0; i < FileData.NumFiles; i++)
{
stream.Align(2);
string filename = stream.ReadAsciiNullTerminatedString();
stream.Seek(1, SeekOrigin.Current);
m_Files.Add(new PackfileEntry(this, entryFileData[i], filename));
stream.Align(2);
}
if (IsCondensed && IsCompressed)
{
DataOffset = 0;
byte[] compressedData = new byte[FileData.CompressedDataSize];
stream.Read(compressedData, 0, (int)FileData.CompressedDataSize);
using (MemoryStream tempStream = new MemoryStream(compressedData))
{
using (Stream s = new ZlibStream(tempStream, CompressionMode.Decompress, true))
{
byte[] uncompressedData = new byte[FileData.DataSize];
s.Read(uncompressedData, 0, (int)FileData.DataSize);
DataStream = new MemoryStream(uncompressedData);
}
}
}
else
{
DataStream = stream;
DataOffset = stream.Position;
}
}
public Packfile(Stream stream)
{
DataStream = stream;
stream.Seek(0, SeekOrigin.Begin);
FileData = stream.ReadStruct <PackfileFileData>();
m_Files = new List <IPackfileEntry>();
stream.Seek(GetEntryDataOffset(), SeekOrigin.Begin);
List <PackfileEntryFileData> entryFileData = new List <PackfileEntryFileData>();
for (int i = 0; i < FileData.IndexCount; i++)
{
var fileData = stream.ReadStruct <PackfileEntryFileData>();
entryFileData.Add(fileData);
}
List <string> fileNames = new List <string>();
for (int i = 0; i < FileData.IndexCount; i++)
{
var fileData = entryFileData[i];
stream.Seek(CalculateEntryNamesOffset() + fileData.FilenameOffset, SeekOrigin.Begin);
string name = stream.ReadAsciiNullTerminatedString();
stream.Seek(CalculateExtensionsOffset() + fileData.ExtensionOffset, SeekOrigin.Begin);
string extension = stream.ReadAsciiNullTerminatedString();
m_Files.Add(new PackfileEntry(this, fileData, name + "." + extension));
}
}
public Packfile(Stream stream)
{
DataStream = stream;
stream.Seek(0, SeekOrigin.Begin);
FileData = stream.ReadStruct<PackfileFileData>();
m_Files = new List<IPackfileEntry>();
stream.Seek(GetEntryDataOffset(), SeekOrigin.Begin);
List<PackfileEntryFileData> entryFileData = new List<PackfileEntryFileData>();
for (int i = 0; i < FileData.IndexCount; i++)
{
var fileData = stream.ReadStruct<PackfileEntryFileData>();
entryFileData.Add(fileData);
}
List<string> fileNames = new List<string>();
for (int i = 0; i < FileData.IndexCount; i++)
{
var fileData = entryFileData[i];
stream.Seek(CalculateEntryNamesOffset() + fileData.FilenameOffset, SeekOrigin.Begin);
string name = stream.ReadAsciiNullTerminatedString();
stream.Seek(CalculateExtensionsOffset() + fileData.ExtensionOffset, SeekOrigin.Begin);
string extension = stream.ReadAsciiNullTerminatedString();
m_Files.Add(new PackfileEntry(this, fileData, name + "." + extension));
}
}
public Packfile(Stream stream, bool isStr2)
{
IsStr2 = isStr2;
stream.Seek(0, SeekOrigin.Begin);
FileData = stream.ReadStruct <PackfileFileData>();
m_Files = new List <IPackfileEntry>();
uint runningPosition = 0;
List <PackfileEntryFileData> entryFileData = new List <PackfileEntryFileData>();
for (int i = 0; i < FileData.NumFiles; i++)
{
PackfileEntryFileData data = stream.ReadStruct <PackfileEntryFileData>();
if (IsCondensed && IsCompressed)
{
data.Flags = 0;
data.Start = runningPosition;
runningPosition += data.Size;
}
else if (IsCondensed)
{
data.Start = runningPosition;
runningPosition += data.Size.Align(16);
}
entryFileData.Add(data);
}
for (int i = 0; i < FileData.NumFiles; i++)
{
stream.Align(2);
string filename = stream.ReadAsciiNullTerminatedString();
stream.Seek(1, SeekOrigin.Current);
m_Files.Add(new PackfileEntry(this, entryFileData[i], filename));
stream.Align(2);
}
if (IsCondensed && IsCompressed)
{
DataOffset = 0;
byte[] compressedData = new byte[FileData.CompressedDataSize];
stream.Read(compressedData, 0, (int)FileData.CompressedDataSize);
using (MemoryStream tempStream = new MemoryStream(compressedData))
{
using (Stream s = new ZlibStream(tempStream, CompressionMode.Decompress, true))
{
byte[] uncompressedData = new byte[FileData.DataSize];
s.Read(uncompressedData, 0, (int)FileData.DataSize);
DataStream = new MemoryStream(uncompressedData);
}
}
}
else
{
DataStream = stream;
DataOffset = stream.Position;
}
}
public StreamingSoundbank(Stream s)
{
DataStream = new MemoryStream();
s.CopyTo(DataStream);
DataStream.Seek(0, SeekOrigin.Begin);
Header = DataStream.ReadStruct <SoundbankHeader>();
if (Header.Signature != 0x42535756)
{
throw new InvalidDataException("File is not a streaming soundbank.");
}
for (int i = 0; i < Header.NumFiles; i++)
{
var fileInfo = DataStream.ReadStruct <SoundbankEntryInfo>();
if ((fileInfo.MetadataLength % 2048) != 0)
{
throw new Exception();
}
if ((fileInfo.Offset % 2048) != 0)
{
throw new Exception();
}
var entry = new SoundbankEntry(this, fileInfo);
Files.Add(entry);
}
}
public bool IsFatxDevice()
{
Stream.Position = 0;
var devkitTable = Stream.ReadStruct <FATX_DEVKIT_PARTITION_TABLE>();
devkitTable.EndianSwap();
if (devkitTable.IsValid)
{
return(true);
}
foreach (var partition in kXboxPartitions)
{
if (DriveSize <= partition.Item2)
{
continue;
}
Stream.Seek(partition.Item2, SeekOrigin.Begin);
var fatxHeader = Stream.ReadStruct <FAT_VOLUME_METADATA>();
if (fatxHeader.IsValid)
{
return(true);
}
}
return(false);
}
public AudioMetadata(Stream stream, IGameInstance instance)
{
Instance = instance;
Header = stream.ReadStruct<AudioMetadataHeader>();
if (Header.LipsyncSize > 0)
{
stream.Seek(0x24 + Header.LipsyncOffset, SeekOrigin.Begin);
LipsyncData = new byte[Header.LipsyncSize];
stream.Read(LipsyncData, 0, LipsyncData.Length);
}
if (Header.SubtitleSize > 0)
{
stream.Seek(0x24 + Header.SubtitleOffset, SeekOrigin.Begin);
SubtitleHeader = stream.ReadStruct<AudioMetadataSubtitleHeader>();
long subtitleOffset = stream.Position;
for (int i = 0; i < SubtitleHeader.LocalizedVoiceSubtitleHeaders.Length; i++)
{
LocalizedVoiceSubtitleHeader localizedVoiceSubtitleHeader = SubtitleHeader.LocalizedVoiceSubtitleHeaders[i];
Language language = (Language)i;
if (localizedVoiceSubtitleHeader.Length == 0)
{
Subtitles.Add(language, "");
continue;
}
long offset = subtitleOffset + localizedVoiceSubtitleHeader.Offset;
stream.Seek(offset, SeekOrigin.Begin);
byte[] subtitleData = new byte[localizedVoiceSubtitleHeader.Length];
stream.Read(subtitleData, 0, (int)localizedVoiceSubtitleHeader.Length);
var map = LanguageUtility.GetDecodeCharMap(instance, language);
StringBuilder subtitleBuilder = new StringBuilder();
for (int pos = 0; pos < subtitleData.Length; pos+=2)
{
char src = BitConverter.ToChar(subtitleData, pos);
char value = src;
if (map.ContainsKey(src))
value = map[src];
if (value == 0x00)
continue;
subtitleBuilder.Append(value);
}
string subtitle = subtitleBuilder.ToString();
Subtitles.Add(language, subtitle);
}
}
}
public ClothSimulationFile(Stream s)
{
Header = s.ReadStruct <ClothSimulationHeader>();
Nodes = new List <SimulatedNodeInfo>();
NodeLinks = new List <SimulatedNodeLinkInfo>();
Ropes = new List <ClothSimRopeInfo>();
RopeNodes = new List <List <uint> >();
RopeLinks = new List <List <uint> >();
CollisionPrimitives = new List <ClothSimCollisionPrimitiveInfo>();
for (int i = 0; i < Header.NumNodes; i++)
{
SimulatedNodeInfo sni = s.ReadStruct <SimulatedNodeInfo>();
Nodes.Add(sni);
}
for (int i = 0; i < Header.NumNodeLinks; i++)
{
SimulatedNodeLinkInfo snli = s.ReadStruct <SimulatedNodeLinkInfo>();
NodeLinks.Add(snli);
}
for (int i = 0; i < Header.NumRopes; i++)
{
ClothSimRopeInfo csri = s.ReadStruct <ClothSimRopeInfo>();
Ropes.Add(csri);
}
for (int i = 0; i < Header.NumRopes; i++)
{
ClothSimRopeInfo csri = Ropes[i];
List <UInt32> ropeNodes = new List <uint>();
for (int j = 0; j < csri.NumNodes; j++)
{
uint ropeNode = s.ReadUInt32();
ropeNodes.Add(ropeNode);
}
RopeNodes.Add(ropeNodes);
List <UInt32> ropeLinks = new List <uint>();
for (int j = 0; j < csri.NumLinks; j++)
{
uint ropeLink = s.ReadUInt32();
ropeLinks.Add(ropeLink);
}
RopeLinks.Add(ropeLinks);
}
for (int i = 0; i < Header.NumColliders; i++)
{
ClothSimCollisionPrimitiveInfo cscpi = s.ReadStruct <ClothSimCollisionPrimitiveInfo>();
CollisionPrimitives.Add(cscpi);
}
}
public override void Deserialize(Stream stream, GameStateSerializer serializer)
{
animationCountdown = stream.ReadStruct <Counter>();
animationIndex = stream.ReadStruct <Counter>();
directionChangeCountdown = stream.ReadStruct <Counter>();
currentOrientation = stream.ReadStruct <ObjectOrientation>();
headingOrientation = stream.ReadStruct <ObjectOrientation>();
base.Deserialize(stream, serializer);
}
public override void Deserialize(Stream stream, GameStateSerializer serializer)
{
spawnCooldown = stream.ReadStruct <Counter>();
surfingSpawnCooldown = stream.ReadStruct <Counter>();
surfingSpawnCooldownNonRounded = stream.ReadFloat();
penguinDurationBonus = stream.ReadFloat();
penguinDestroyBonus = stream.ReadFloat();
base.Deserialize(stream, serializer);
}
// Ref 16 bit: https://blogs.msdn.microsoft.com/oldnewthing/20040618-00/?p=38803
// Ref 32 bit: https://blogs.msdn.microsoft.com/oldnewthing/20040621-00/?p=38793
public static byte[] ConvertDialogTemplate(Stream strm)
{
var ms = new MemoryStream();
// Convert header
var header16 = strm.ReadStruct <Win16.DLGHEADER>();
header16.x = (ushort)(header16.x * 118 / 100);
header16.cx = (ushort)(header16.cx * 118 / 100);
ms.WriteStruct(header16.Convert());
// Convert strings
ms.WriteResourceString32(strm.ReadResourceString16()); // Menu name
ms.WriteResourceString32(strm.ReadResourceString16()); // Class name
ms.WriteResourceString32(strm.ReadResourceString16()); // Title
// Font?
if ((header16.dwStyle & Win16.DS_SETFONT) != 0)
{
ms.WriteUInt16(strm.ReadUInt16()); // Point size
ms.WriteUnicodeString(strm.ReadNullTerminatedString()); // Font name
}
// Convert all controls
for (int i = 0; i < header16.cItems; i++)
{
ms.Pad(4);
// Common header
var item16 = strm.ReadStruct <Win16.DLGITEMHEADER>();
item16.x = (ushort)(item16.x * 118 / 100);
item16.cx = (ushort)(item16.cx * 118 / 100);
ms.WriteStruct(item16.Convert());
// Class name
ms.WriteResourceString32(strm.ReadResourceString16(true), true);
// Control text
ms.WriteResourceString32(strm.ReadResourceString16(), true);
// Extra data
var byteCount = strm.ReadByte();
ms.WriteUInt16((ushort)byteCount);
if (byteCount > 0)
{
var buf = new byte[byteCount];
strm.Read(buf, 0, buf.Length);
ms.Write(buf, 0, buf.Length);
}
}
var data = ms.ToArray();
System.IO.File.WriteAllBytes("dlg.bin", data);
return(data);
}
public static Win16.GroupIcon LoadIconOrCursorGroup(Stream strm)
{
var g = new Win16.GroupIcon();
g.Directory = strm.ReadStruct <Win16.GRPICONDIR>();
for (int i = 0; i < g.Directory.idCount; i++)
{
var de = strm.ReadStruct <Win16.GRPICONDIRENTRY>();
g.Entries.Add(de);
}
return(g);
}
public BattleBinFileHeader ReadHeader()
{
_header = _input.ReadStruct <BattleBinFileHeader>();
if (_header.Count != 8)
{
throw new Exception();
}
if (_header.DescriptorOffset != 0x30)
{
throw new NotSupportedException();
}
return(_header);
}
public TXM Load(Stream TXMStream, Stream TXVStream)
{
this.TXVStream = TXVStream;
if (!IsValid(TXMStream.Slice().ReadBytesUpTo(0x100)))
{
throw(new Exception("Invalid TXM!"));
}
this.ImageVersion = TXMStream.Slice().ReadStruct <ImageVersionStruct>();
if (ImageVersion.Version == 1)
{
this.Surface2DEntriesByName = new Dictionary <string, Surface2DEntryInfo>();
this.Surface2DEntries = new Surface2DEntryInfo[0];
this.Surface3DEntriesByName = new Dictionary <string, Surface3DEntryInfo>();
this.Surface3DEntries = new Surface3DEntryInfo[0];
Console.Error.WriteLine("Not Implemented TXM V1!!!!!!!");
}
else
{
this.ImageHeader = TXMStream.ReadStruct <ImageHeaderStructV2>();
this.Surface2DEntriesByName = new Dictionary <string, Surface2DEntryInfo>();
this.Surface2DEntries = new Surface2DEntryInfo[ImageHeader.Surface2DCount];
for (int n = 0; n < ImageHeader.Surface2DCount; n++)
{
var ImageEntry = TXMStream.ReadStruct <Surface2DInfoStructV2>();
var Name = TXMStream.SliceWithLength(TXMStream.Position + Marshal.OffsetOf(typeof(Surface2DInfoStructV2), "StringOffset").ToInt32() - sizeof(Surface2DInfoStructV2) + ImageEntry.StringOffset).ReadStringz();
var Entry = new Surface2DEntryInfo(this, n, ImageEntry, Name);
this.Surface2DEntries[n] = Entry;
this.Surface2DEntriesByName[Name] = Entry;
}
this.Surface3DEntriesByName = new Dictionary <string, Surface3DEntryInfo>();
this.Surface3DEntries = new Surface3DEntryInfo[ImageHeader.Surface3DCount];
if (this.ImageHeader.VersionInfo.Version != 1)
{
for (int n = 0; n < ImageHeader.Surface3DCount; n++)
{
var ImageEntry = TXMStream.ReadStruct <Surface3DInfoStructV2>();
var Name = TXMStream.SliceWithLength(TXMStream.Position + Marshal.OffsetOf(typeof(Surface3DInfoStructV2), "StringOffset").ToInt32() - sizeof(Surface3DInfoStructV2) + ImageEntry.StringOffset).ReadStringz();
var Entry = new Surface3DEntryInfo(this, n, ImageEntry, Name);
this.Surface3DEntries[n] = Entry;
this.Surface3DEntriesByName[Entry.Name] = Entry;
}
}
}
return(this);
}
/// <summary>
/// Decompresses and copies a segment of zsize bytes from a stream to another stream
/// </summary>
/// <param name="stream"></param>
/// <param name="outStream"></param>
/// <param name="zSize"></param>
/// <param name="size"></param>
/// <exception cref="Exception"></exception>
/// <exception cref="DecompressionException"></exception>
public static void DecompressAndCopySegment(this Stream stream, Stream outStream, uint zSize, uint size)
{
if (zSize == size)
{
stream.CopyToWithLength(outStream, (int)zSize);
}
else
{
var oodleCompression = stream.ReadStruct <uint>();
if (oodleCompression == KARK)
{
var headerSize = stream.ReadStruct <uint>();
if (headerSize != size)
{
throw new Exception($"Buffer size doesn't match size in info table. {headerSize} vs {size}");
}
var inputBuffer = new byte[(int)zSize - 8];
stream.Read(inputBuffer);
var outputBuffer = new byte[size];
long unpackedSize = OodleHelper.Decompress(inputBuffer, outputBuffer);
if (unpackedSize != size)
{
throw new DecompressionException(
$"Unpacked size {unpackedSize} doesn't match real size {size}.");
}
outStream.Write(outputBuffer);
// try
// {
//
// }
// catch (DecompressionException)
// {
// //logger.LogString(e.Message, Logtype.Error);
// //logger.LogString(
// // $"Unable to decompress file {hash.ToString()}. Exporting uncompressed file",
// // Logtype.Error);
// stream.CopyTo(outStream);
// }
}
else
{
stream.Seek(0, SeekOrigin.Begin);
stream.CopyToWithLength(outStream, (int)zSize);
}
}
}
public static RpmPackage Read(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (!stream.CanSeek)
{
throw new ArgumentOutOfRangeException(nameof(stream), "A stream which backs a RPM package must be seekable");
}
RpmPackage package = new RpmPackage();
package.Stream = stream;
package.Lead = stream.ReadStruct <RpmLead>();
package.Signature = ReadSection <SignatureTag>(stream, h => (SignatureTag)h.Tag);
if (stream.Position % 8 != 0)
{
stream.Position += 8 - (stream.Position % 8);
}
package.HeaderOffset = stream.Position;
package.Header = ReadSection <IndexTag>(stream, h => (IndexTag)h.Tag);
package.PayloadOffset = stream.Position;
return(package);
}
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);
}
}
public static ObjectsTable ReadObjectsTable(Stream data)
{
/*var baseArcHeader = archiveHeader is BaseHeader
* ? (BaseHeader) archiveHeader
* : ((DX11Header) archiveHeader).baseHeader;*/
ObjectsTable result = new ObjectsTable();
result.header = data.ReadStruct <ObjectsTable.Header>();
result.typeDescriptors = data.ReadStructArray <ObjectsTable.TypeDescriptor>(result.header.typeCount).ToArray();
result.classDescriptors = data.ReadStructArray <ObjectsTable.ClassDescriptor>(result.header.classCount).ToArray();
result.classMemberDescriptors = data.ReadStructArray <ObjectsTable.ClassMemberDescriptor>(result.header.classMemberCount).ToArray();
result.stringTable = data.ReadBytes((int)result.header.stringTableSize);
var s0 = Marshal.SizeOf <ObjectsTable.Header>();
var s1 = Marshal.SizeOf <ObjectsTable.TypeDescriptor>() * result.header.typeCount;
var s2 = Marshal.SizeOf <ObjectsTable.ClassDescriptor>() * result.header.classCount;
var s3 = Marshal.SizeOf <ObjectsTable.ClassMemberDescriptor>() * result.header.classMemberCount;
var s4 = result.header.stringTableSize;
var paddingSize = result.header.size - (s0 + s1 + s2 + s3 + s4);
if (paddingSize != 0)
{
data.ReadBytes((int)paddingSize);
}
return(result);
}
public static object ReadHeader(Stream data)
{
var baseHeader = data.ReadStruct <BaseHeader>();
var baseSize = Marshal.SizeOf <BaseHeader>();
if (baseHeader.size < baseSize)
{
throw new Exception("Unexpected header size");
}
if (baseHeader.size == baseSize)
{
return(baseHeader);
}
if (baseHeader.platformId.Value == 0x44583131)
{
//dx11 platform
var dx11Size = Marshal.SizeOf <DX11Header>();
var extraBytesCount = dx11Size - baseSize;
var extraBytes = data.ReadBytes(extraBytesCount);
var baseBytes = MemoryUtils.StructToBytes(baseHeader);
List <byte> dx11Bytes = new List <byte>();
dx11Bytes.AddRange(baseBytes);
dx11Bytes.AddRange(extraBytes);
return(MemoryUtils.BytesToStruct <DX11Header>(dx11Bytes.ToArray()));
}
throw new Exception("Unknown platform");
}
public SE3 Load(Stream Stream)
{
var Header = Stream.ReadStruct <HeaderStruct>();
if (Header.Magic != 0x53453320)
{
throw(new Exception("Not a SE3 File"));
}
var NameStream = Stream.SliceWithLength(0x10, Header.NameSize);
var ELBP = NameStream.ReadStruct <uint_be>();
var NameCount = (uint)NameStream.ReadStruct <uint_be>();
Entries = new List <SE3Entry>();
EntriesWithName = new Dictionary <string, SE3Entry>();
for (int n = 0; n < NameCount; n++)
{
var Entry = new SE3Entry()
{
Name = NameStream.ReadStringz(0x30),
};
Entries.Add(Entry);
EntriesWithName[Entry.Name] = Entry;
}
_LoadData(Stream.SliceWithLength(Header.DataStart));
return(this);
}
public Pe LoadHeader(Stream _ExeStream)
{
ExeStream = _ExeStream;
DosExe = new DosExe().LoadHeader(ExeStream);
PeStream = ExeStream.SliceWithLength(DosExe.Header.OffsetToPEHeader);
PeHeader = PeStream.ReadStruct<PeHeaderStruct>();
OptionalHeaderStream = PeStream.ReadStream(PeHeader.SizeOfOptionalHeader);
PeOptionalHeader = OptionalHeaderStream.ReadStruct<PeOptionalHeaderStruct>();
ImageSectionHeaderList = new ImageSectionHeader[PeHeader.NumSections];
for (int n = 0; n < PeHeader.NumSections; n++)
{
ImageSectionHeaderList[n] = PeStream.ReadStruct<ImageSectionHeader>();
}
return this;
}
public static Sprite Read(Stream stream)
{
ShpHeader header = stream.ReadStruct <ShpHeader>();
ShpOffset[] offsets = new ShpOffset[2 + header.nframes];
for (uint i = 0; i < offsets.Length; i++)
{
offsets[i] = stream.ReadStruct <ShpOffset>();
}
int frame_w = header.width;
int frame_h = header.height;
byte[][] frames = Decode(stream, offsets, frame_w, frame_h, header.nframes);
return(new Sprite(frames, frame_w, frame_h));
}
public static TimHeader Read(Stream input)
{
TimHeader result = input.ReadStruct <TimHeader>();
result.Validate();
return(result);
}
public static ResourceEntry Load(Stream stream)
{
var entry = new ResourceEntry();
entry.Header = stream.ReadStruct <LfdHeader>();
entry.LoadData(stream);
return(entry);
}
public StreamingSoundbank(Stream s)
{
DataStream = new MemoryStream();
s.CopyTo(DataStream);
DataStream.Seek(0, SeekOrigin.Begin);
Header = DataStream.ReadStruct<SoundbankHeader>();
if (Header.Signature != 0x42535756)
throw new InvalidDataException("File is not a streaming soundbank.");
for (int i = 0; i < Header.NumFiles; i++)
{
var fileInfo = DataStream.ReadStruct<SoundbankEntryInfo>();
var entry = new SoundbankEntry(this, fileInfo);
Files.Add(entry);
}
}
/*
*
* Programming Guide for DDS
* https://msdn.microsoft.com/en-us/library/windows/desktop/bb943991(v=vs.85).aspx#File_Layout1
*
* File Structure
*
* DWORD dwMagic;
* DDS_HEADER header;
*
* If the DDS_PIXELFORMAT dwFlags is set to DDPF_FOURCC and dwFourCC is set to "DX10" an additional DDS_HEADER_DXT10
*
* DDS_HEADER_DXT10 header10;
*
* A pointer to an array of bytes that contains the main surface data.
*
* BYTE bdata[]
*
* BYTE bdata2[]
*
*/
public static DDS read(Stream stream)
{
var dds = new DDS();
int readIndex = 0;
// Read headers
DDS_Magic fileMagicData;
readIndex += stream.ReadStruct(out fileMagicData);
readIndex += stream.ReadStruct(out dds.ddsHeader);
// Only read the ddsHeaderDXT10 when the FOURCC.DX10 is set
if (dds.ddsHeader.ddspf.dwFourCC == DDS_PIXELFORMAT.FOURCC.DX10)
{
readIndex += stream.ReadStruct(out dds.ddsHeaderDXT10);
}
if (dds.ddsHeader.ddspf.dwFourCC != DDS_PIXELFORMAT.FOURCC.DXT1 ||
(dds.ddsHeader.dwFlags & DDS_HEADER.Flags.DDSD_LINEARSIZE) == 0)
{
throw new NotImplementedException("Format not implemented");
}
// Initialize and read DXT1 blocks
var size = dds.height * dds.width;
dds.blocks = new DXT1Block[size];
for (uint i = 0; i < size; i++)
{
DDS_DXT1Block block;
readIndex += stream.ReadStruct(out block);
dds.blocks[i] = block;
}
return dds;
}
public Chunk ReadChunk(Stream Stream)
{
var ChunkSize = (uint)Stream.ReadStruct<uint_be>();
//var ChunkType = (ushort)Stream.ReadStruct<ushort_be>();
var ChunkStream = Stream.ReadStream(ChunkSize);
return new Chunk()
{
Size = ChunkSize,
//Type = ChunkType,
Stream = ChunkStream,
};
}
public void Load(Stream Stream)
{
Entries = new Dictionary<string, Entry>();
Stream.Position = 8;
while (Stream.Position < Stream.Length)
{
var Entry = Stream.ReadStruct<Entry>();
if (Entry.ImageId != 0)
{
Entries.Add(Entry.Name, Entry);
}
}
}
public Pmf Load(Stream Stream)
{
Header = Stream.ReadStruct<HeaderStruct>();
var Chunk = ReadChunk(Stream.SliceWithLength(0x50));
InfoHeader = Chunk.Stream.ReadStruct<InfoHeaderStruct>();
/*
Console.WriteLine("0x{0:X}", (ulong)InfoHeader.FirstTimestamp);
Console.WriteLine("0x{0:X}", (ulong)InfoHeader.LastTimestamp);
Console.WriteLine("{0}", (ulong)InfoHeader.Width);
Console.WriteLine("{0}", (ulong)InfoHeader.Height);
*/
return this;
}
public virtual void Load(Stream FileStream, string Name)
{
FileStream = new MemoryStream(FileStream.ReadAll());
this.FileStream = FileStream;
this.Header = FileStream.ReadStruct<Elf.HeaderStruct>();
if (this.Header.Magic != Elf.HeaderStruct.MagicEnum.ExpectedValue)
{
throw(new InvalidProgramException("Not an ELF File '" + Name + "'"));
}
if (this.Header.Machine != Elf.HeaderStruct.MachineEnum.ALLEGREX)
{
throw (new InvalidProgramException("Invalid Elf.Header.Machine"));
}
this.ProgramHeaders = FileStream.ReadStructVectorAt<Elf.ProgramHeader>(Header.ProgramHeaderOffset, Header.ProgramHeaderCount, Header.ProgramHeaderEntrySize);
this.SectionHeaders = FileStream.ReadStructVectorAt<Elf.SectionHeader>(Header.SectionHeaderOffset, Header.SectionHeaderCount, Header.SectionHeaderEntrySize);
this.NamesSectionHeader = this.SectionHeaders[Header.SectionHeaderStringTable];
this.StringTable = FileStream.SliceWithLength(this.NamesSectionHeader.Offset, this.NamesSectionHeader.Size).ReadAll();
this.SectionHeadersByName = new Dictionary<string, Elf.SectionHeader>();
foreach (var SectionHeader in this.SectionHeaders)
{
var SectionHeaderName = GetStringFromStringTable(SectionHeader.Name);
this.SectionHeadersByName[SectionHeaderName] = SectionHeader;
}
Console.WriteLine("ProgramHeaders:{0}", this.ProgramHeaders.Length);
foreach (var ProgramHeader in ProgramHeaders)
{
Console.WriteLine("{0}", ProgramHeader.ToStringDefault());
}
Console.WriteLine("SectionHeaders:{0}", this.SectionHeaders.Length);
foreach (var SectionHeader in SectionHeaders)
{
Console.WriteLine("{0}:{1}", GetStringFromStringTable(SectionHeader.Name), SectionHeader.ToStringDefault());
}
if (NeedsRelocation && this.ProgramHeaders.Length > 1)
{
//throw (new NotImplementedException("Not implemented several ProgramHeaders yet using relocation"));
}
}
public SaveFile(Stream s)
{
MainHeader = s.ReadStruct<SaveGameMainHeader>();
while (s.Position < s.Length)
{
long sectionStart = s.Position;
Section section = new Section(s);
if (section.Size == 0 && section.Version == 0)
break;
Console.WriteLine("Got {0} ({4:X2}) at {3:X4}. Version {1:X2}, {2:X4} bytes.", section.SectionId, section.Version, section.Size, sectionStart, (uint)section.SectionId);
Sections.Add(section.SectionId, section);
}
Player = new PlayerSection(Sections[SectionId.GSSI_PLAYER]);
}
public Pbp Load(Stream Stream)
{
this.Stream = Stream;
this.Header = Stream.ReadStruct<HeaderStruct>();
this.Files = new Dictionary<string, Stream>();
if (Header.Magic != HeaderStruct.MagicEnum.ExpectedValue)
{
throw(new Exception("Not a PBP file"));
}
var Offsets = Header.Offsets.Concat(new[] { (uint)Stream.Length }).ToArray();
for (int n = 0; n < 8; n++)
{
Files[Names[n]] = Stream.SliceWithBounds(Offsets[n + 0], Offsets[n + 1]);
}
return this;
}
public Psf Load(Stream Stream)
{
EntryDictionary = new Dictionary<string, object>();
Header = Stream.ReadStruct<HeaderStruct>();
Entries = Stream.ReadStructVector<EntryStruct>(Header.NumberOfPairs);
KeysStream = Stream.SliceWithLength(Header.KeyTable);
ValuesStream = Stream.SliceWithLength(Header.ValueTable);
foreach (var Entry in Entries)
{
var Key = KeysStream.ReadStringzAt(Entry.KeyOffset);
var ValueStream = ValuesStream.SliceWithLength(Entry.ValueOffset, Entry.ValueSize);;
switch (Entry.DataType)
{
case DataType.Binary: EntryDictionary[Key] = ValueStream.ReadAll(); break;
case DataType.Int: EntryDictionary[Key] = ValueStream.ReadStruct<int>(); break;
case DataType.Text: EntryDictionary[Key] = ValueStream.ReadStringz(-1, Encoding.UTF8); break;
default: throw(new NotImplementedException());
}
}
return this;
}
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);
}
}
public CodeNode Read(Stream stream)
{
return new CodeNode
{
stream.ReadStruct(out Length, nameof(Length)),
stream.ReadAnything(out Data, StreamExtensions.ReadByteArray((int)Length), nameof(Data)),
};
}
public Section(Stream s)
{
Header = s.ReadStruct<SaveGameSectionHeader>();
Data = new byte[Header.Size];
s.Read(Data, 0, (int)Header.Size);
}
public PGF Load(Stream FileStream)
{
this.Header = FileStream.ReadStruct<HeaderStruct>();
if (this.Header.Revision >= 3)
{
this.HeaderExtraRevision3 = FileStream.ReadStruct<HeaderRevision3Struct>();
}
FileStream.ReadStructVector(ref DimensionTable, Header.TableDimLength);
FileStream.ReadStructVector(ref XAdjustTable, Header.TableXAdjustLength);
FileStream.ReadStructVector(ref YAdjustTable, Header.TableYAdjustLength);
FileStream.ReadStructVector(ref AdvanceTable, Header.TableAdvanceLength);
PackedShadowCharMap = FileStream.ReadBytes(BitsToBytesHighAligned(Header.TableShadowMapLength * Header.TableShadowMapBpe));
if (Header.Revision == 3)
{
FileStream.ReadStructVector(ref CharmapCompressionTable1, HeaderExtraRevision3.TableCompCharMapLength1);
FileStream.ReadStructVector(ref CharmapCompressionTable2, HeaderExtraRevision3.TableCompCharMapLength2);
}
PackedCharMap = FileStream.ReadBytes(BitsToBytesHighAligned(Header.TableCharMapLength * Header.TableCharMapBpe));
PackedCharPointerTable = FileStream.ReadBytes(BitsToBytesHighAligned(Header.TableCharPointerLength * Header.TableCharPointerBpe));
/*
int BytesLeft = (int)(FileStream.Length - FileStream.Position);
charData = new byte[BytesLeft];
FileStream.Read(charData, 0, BytesLeft);
*/
CharData = FileStream.ReadBytes((int)(FileStream.Length - FileStream.Position));
var NumberOfCharacters = Header.TableCharPointerLength;
CharMap = new int[Header.FirstGlyph + Header.LastGlyph + 1];
CharPointer = new int[NumberOfCharacters];
Glyphs = new Glyph[NumberOfCharacters];
ReverseCharMap = new Dictionary<int, int>();
ShadowCharMap = new Dictionary<int, int>();
ReverseShadowCharMap = new Dictionary<int, int>();
foreach (var Pair in BitReader.FixedBitReader(PackedShadowCharMap, Header.TableShadowMapBpe))
{
var UnicodeIndex = (int)Pair.Key + Header.FirstGlyph;
var GlyphIndex = (int)Pair.Value;
ShadowCharMap[UnicodeIndex] = GlyphIndex;
ReverseShadowCharMap[GlyphIndex] = UnicodeIndex;
}
foreach (var Pair in BitReader.FixedBitReader(PackedCharMap, Header.TableCharMapBpe))
{
var UnicodeIndex = (int)Pair.Key + Header.FirstGlyph;
var GlyphIndex = (int)Pair.Value;
CharMap[UnicodeIndex] = GlyphIndex;
ReverseCharMap[GlyphIndex] = UnicodeIndex;
}
foreach (var Pair in BitReader.FixedBitReader(PackedCharPointerTable, Header.TableCharPointerBpe))
{
CharPointer[Pair.Key] = (int)Pair.Value;
}
/*
for (int n = 0; n < NumberOfCharacters; n++)
{
Glyphs[n] = new Glyph().Read(this, n);
}
*/
Console.WriteLine(this.Header.FontName);
/*
Console.WriteLine(this.header.fontName);
for (int n = 0; n < 300; n++)
{
Console.WriteLine(GetGlyphId((char)n));
}
*/
return this;
}
public DosExe LoadHeader(Stream ExeStream)
{
this.Header = ExeStream.ReadStruct<DosExe.HeaderStruct>();
return this;
}
public static BMP read(Stream stream)
{
var image = new BMP();
int readIndex = 0;
// Read headers
readIndex += stream.ReadStruct(out image.fileHeader);
readIndex += stream.ReadStruct(out image.infoHeader);
if (image.infoHeader.biBitCount != 24 ||
image.infoHeader.biCompression != BITMAPINFOHEADER.CompressionMode.BI_RGB)
{
throw new NotImplementedException("Format not implemented");
}
// Ensure we jump to the offset
int seek = (int)image.fileHeader.bfOffBits - readIndex;
stream.Seek(seek, SeekOrigin.Current);
uint _height = image.uheight;
uint _width = image.width;
uint _size = _height * _width;
// Initialize pixel matrix
image.pixels = new BGR[_size];
uint imagePadding = image.padding;
// Optimize loop if there is no padding
if (imagePadding > 0)
{
uint index = 0;
for (uint i = 0; i < _height; i++)
{
for (uint j = 0; j < _width; j++, index++)
{
BGR color;
readIndex += stream.ReadStruct(out color);
image[index] = color;
}
if (imagePadding > 0)
{
stream.Seek(imagePadding, SeekOrigin.Current);
}
}
}
else
{
for (uint i = 0; i < _size; i++)
{
BGR color;
readIndex += stream.ReadStruct(out color);
image[i] = color;
}
}
return image;
}
protected void PreloadStrings(Stream input)
{
try
{
if (Strings.Count > 0) Strings.Clear();
_bundleFileHeader = input.ReadStruct<FileHeaderStruct>();
if (_bundleFileHeader.Magic != GETTEXT_MAGIC)
throw new IOException("Invalid MAGIC");
var originalHeaders = ReadStringHeaders(input, _bundleFileHeader.OriginalTableOffset,
_bundleFileHeader.NumberOfStrings);
var translationHeaders = ReadStringHeaders(input, _bundleFileHeader.TranslationTableOffset,
_bundleFileHeader.NumberOfStrings);
var originals = new string[_bundleFileHeader.NumberOfStrings][];
var translations = new string[_bundleFileHeader.NumberOfStrings][];
for (var x = 0; x < _bundleFileHeader.NumberOfStrings; x++)
originals[x] = ReadTextEntry(input, originalHeaders[x].Offset, originalHeaders[x].Length);
for (var x = 0; x < _bundleFileHeader.NumberOfStrings; x++)
translations[x] = ReadTextEntry(input, translationHeaders[x].Offset, translationHeaders[x].Length);
for (var x = 0; x < _bundleFileHeader.NumberOfStrings; x++)
{
switch (originals[x].Length)
{
case 1:
Strings.TryAdd(originals[x][0], translations[x]);
break;
case 2:
Strings.TryAdd(originals[x][0], new[] {translations[x][0]});
Strings.TryAdd(originals[x][1], translations[x]);
break;
}
}
}
finally
{
_headerMsg = new HeaderMsg(GetString(string.Empty));
}
}
public CodeNode Read(Stream stream)
{
Node = new CodeNode
{
stream.ReadStruct(out Offset, nameof(Offset)),
stream.ReadStruct(out Flags, nameof(Flags)),
stream.ReadClass(ref Name, nameof(Name)),
stream.ReadClass(ref Implementation, nameof(Implementation)),
};
Section section = Singletons.Instance.TildeStream.Section;
section.ReadNode(strm =>
{
section.Reposition(strm, section.CLIHeader.Resources.RVA + Offset);
ResourceEntry entry = null;
return stream.ReadClass(ref entry);
});
return Node;
}
public void Load(Stream Stream, ThreadContext ThreadContext)
{
var Memory = ThreadContext.CpuContext.Memory;
var DosHeader = Stream.ReadStruct<IMAGE_DOS_HEADER>();
Stream.Position = DosHeader.AddressOfNewExeHeader;
var NtHeader = Stream.ReadStruct<IMAGE_NT_HEADERS>();
int len = NtHeader.OptionalHeader.NumberOfRvaAndSizes;
if (len >= 1) Export = Stream.ReadStruct<DATA_DIR>();
if (len >= 2) Import = Stream.ReadStruct<DATA_DIR>();
if (len >= 3) Resource = Stream.ReadStruct<DATA_DIR>();
if (len >= 4) Exception = Stream.ReadStruct<DATA_DIR>();
if (len >= 5) Security = Stream.ReadStruct<DATA_DIR>();
if (len >= 6) BaseRelocationTable = Stream.ReadStruct<DATA_DIR>();
if (len >= 7) DebugDirectory = Stream.ReadStruct<DATA_DIR>();
if (len >= 8) CopyrightOrArchitectureSpecificData = Stream.ReadStruct<DATA_DIR>();
if (len >= 9) GlobalPtr = Stream.ReadStruct<DATA_DIR>();
if (len >= 10) TLSDirectory = Stream.ReadStruct<DATA_DIR>();
if (len >= 11) LoadConfigurationDirectory = Stream.ReadStruct<DATA_DIR>();
if (len >= 12) BoundImportDirectory = Stream.ReadStruct<DATA_DIR>();
if (len >= 13) ImportAddressTable = Stream.ReadStruct<DATA_DIR>();
if (len >= 14) DelayLoadImportDescriptors = Stream.ReadStruct<DATA_DIR>();
if (len >= 15) COMRuntimedescriptor = Stream.ReadStruct<DATA_DIR>();
if (len >= 16) Reserved = Stream.ReadStruct<DATA_DIR>();
var Sections = new List<IMAGE_SECTION_HEADER>();
for (int n = 0; n < NtHeader.FileHeader.NumberOfSections; n++)
{
Sections.Add(Stream.ReadStruct<IMAGE_SECTION_HEADER>());
}
var ImageBase = NtHeader.OptionalHeader.ImageBase;
foreach (var Section in Sections)
{
Stream.Position = Section.PointerToRawData;
var Data = new byte[Section.VirtualSize];
Stream.Read(Data, 0, Data.Length);
Memory.Write(ImageBase + Section.VirtualAddress, Data);
}
ThreadContext.PC = ImageBase + NtHeader.OptionalHeader.AddressOfEntryPoint;
ThreadContext.ESP = (uint)(Memory.AllocStack(NtHeader.OptionalHeader.SizeOfStackReserve) + NtHeader.OptionalHeader.SizeOfStackReserve);
var VirtualStream = Memory.GetStream().SliceWithLength(ImageBase);
VirtualStream.Position = Import.VirtualAddress;
var ImportDirectoryCount = Import.Size / Marshal.SizeOf(typeof(IMPORT_DIRECTORY_TABLE));
for (int n = 0; n < ImportDirectoryCount; n++)
{
var ImportDirectory = VirtualStream.ReadStruct<IMPORT_DIRECTORY_TABLE>();
if (ImportDirectory.NameRVA != 0)
{
var DllName = VirtualStream.SliceWithLength(ImportDirectory.NameRVA).ReadStringz();
var Imports = VirtualStream.SliceWithLength(ImportDirectory.ImportLookupTableRVA);
var ImportsReader = new BinaryReader(Imports);
uint POS = ImportDirectory.ImportAddressTableRVA;
uint JumpAddress = 0x100;
while (true)
{
var ImportLookupAddress = ImportsReader.ReadUInt32();
if (ImportLookupAddress == 0) break;
var ImportLookupStream = VirtualStream.SliceWithLength(ImportLookupAddress);
ImportLookupStream.ReadByte();
ImportLookupStream.ReadByte();
var Name = ImportLookupStream.ReadStringz();
//Console.WriteLine("{0} : 0x{1:X} : {2} <-- 0x{3:X}", DllName, POS, Name, JumpAddress);
new BinaryWriter(VirtualStream.SliceWithLength(POS)).Write((uint)JumpAddress);
var JumpStream = new BinaryWriter(Memory.GetStream().SliceWithLength(JumpAddress));
JumpStream.Write(new byte[] { 0xCD, 0x01 });
JumpStream.Write((uint)JumpAddress);
ThreadContext.CpuContext.NativeMethodInfoList[JumpAddress] = CreateNativeMethodInfo(DllName, Name);
POS += 4;
JumpAddress += 6;
}
}
}
//Console.WriteLine(DosHeader.Magic);
//BinaryFormatter BinaryFormatter = new BinaryFormatter();
//var Header = (IMAGE_DOS_HEADER)BinaryFormatter.Deserialize(Stream);
//Marshal.StructureToPtr
}
private static StringHeaderStruct[] ReadStringHeaders(Stream input, uint offset, uint count)
{
var headers = new StringHeaderStruct[count];
input.Seek(offset, SeekOrigin.Begin);
for (var x = 0; x < count; x++)
headers[x] = input.ReadStruct<StringHeaderStruct>();
return (headers);
}
public CodeNode Read(Stream stream)
{
CodeNode rva;
Node = new CodeNode
{
(rva = stream.ReadStruct(out RVA, nameof(RVA))),
stream.ReadClass(ref ImplFlags, nameof(ImplFlags)),
stream.ReadClass(ref Flags, nameof(Flags)),
stream.ReadClass(ref Name, nameof(Name)),
stream.ReadClass(ref Signature, nameof(Signature)),
stream.ReadClass(ref ParamList, nameof(ParamList)),
};
rva.DelayedValueNode = () => new DefaultValueNode(
rva.Value,
RVA > 0 ? Singletons.Instance.MethodsByRVA[RVA].Node : null);
return Node;
}
public static int Play(Stream Stream, Stream OutStream)
{
var strt = Stream.ReadString(3);
Stream.Position = 0;
ushort bztmp = 0;
if (strt == "ea3")
{
//we get ea3 header
Console.WriteLine("ea3 header\n");
Stream.Position = 0x6;
var tmp = Stream.ReadBytes(4);
int skipbytes = 0;
for (int a0 = 0; a0 < 4; a0++)
{
skipbytes <<= 7;
skipbytes += tmp[a0] & 0x7F;
}
Stream.Skip(skipbytes);
}
if (strt == "RIF") //RIFF
{
//we get RIFF header
Console.WriteLine("RIFF header\n");
Stream.Position = 0x10;
var fmt_size = Stream.ReadStruct<int>();
var fmt = Stream.ReadStruct<ushort>();
if (fmt != 0xFFFE)
{
Console.WriteLine("RIFF File fmt error\n");
return -1;
}
Stream.Skip(0x28);
bztmp = Stream.ReadStruct<ushort_be>();
Stream.Skip(fmt_size - 0x2c);
//search the data chunk
for (int a0 = 0; a0 < 0x100; a0++)
{
if (Stream.ReadString(4) == "atad") break;
}
int tmpr = Stream.ReadStruct<int>();
}
else
{
//EA3 block that contains at3+ stream
Console.WriteLine("EA3 header");
Stream.Skip(0x22);
Console.WriteLine("{0:X}", Stream.Position);
bztmp = (ushort)Stream.ReadStruct<ushort_be>();
Stream.Skip(0x3c);
}
int blocksz = bztmp & 0x3FF;
var buf0 = new byte[0x3000];
fixed (byte* buf0_ptr = buf0)
{
//calculate the frame block size here
int block_size = blocksz * 8 + 8;
Console.WriteLine("frame_block_size 0x{0:X}\n", block_size);
//Console.ReadKey();
//so we make a new at3+ frame decoder
MaiAT3PlusFrameDecoder d2 = new MaiAT3PlusFrameDecoder();
Stream.Read(buf0, 0, block_size);
int chns = 0;
short[] p_buf;
int rs;
//decode the first frame and get channel num
//for (int n = 0; n < block_size; n++) Console.Write(buf0[n]);
if ((rs = d2.decodeFrame(buf0_ptr, block_size, out chns, out p_buf)) != 0) Console.WriteLine("decode error {0}", rs);
Console.WriteLine("channels: {0}\n", chns);
if (chns > 2) Console.WriteLine("warning: waveout doesn't support {0} chns\n", chns);
//just waveout
//MaiWaveOutI *mwo0 = new MaiWaveOutI(chns, 44100, 16);
//mwo0.play();
while (!Stream.Eof())
{
Stream.Read(buf0, 0, block_size);
//decode frame and get sample data
if ((rs = d2.decodeFrame(buf0_ptr, block_size, out chns, out p_buf)) != 0) Console.WriteLine("decode error {0}", rs);
//play it
OutStream.WriteStructVector(p_buf, 0x800 * chns);
//mwo0.enqueue((Mai_I8*)p_buf, 0x800 * chns * 2);
}
//while (mwo0.getRemainBufSize()) Mai_Sleep(1);
return 0;
}
}
/// <summary>
/// Decodes the TGA file header.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="offset">The offset in the stream at which the data starts.</param>
/// <param name="convFlags">The conversion flags.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="stream"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="InvalidDataException">
/// Invalid data.
/// </exception>
/// <exception cref="NotSupportedException">
/// The specified format is not supported.
/// </exception>
private static TextureDescription DecodeTGAHeader(Stream stream, out int offset, out ConversionFlags convFlags)
{
if (stream == null)
throw new ArgumentNullException("stream");
TextureDescription description = new TextureDescription
{
Dimension = TextureDimension.Texture2D,
Format = DataFormat.R8G8B8A8_UNORM,
};
offset = 0;
convFlags = ConversionFlags.None;
long size = stream.Length - stream.Position;
int sizeOfTGAHeader = Marshal.SizeOf(typeof(Header));
if (size < sizeOfTGAHeader)
throw new InvalidDataException("The TGA file is corrupt.");
var header = stream.ReadStruct<Header>();
if (header.ColorMapType != 0 || header.ColorMapLength != 0)
throw new NotSupportedException("TGA files with color maps are not supported.");
if ((header.Descriptor & (DescriptorFlags.Interleaved2Way | DescriptorFlags.Interleaved4Way)) != 0)
throw new NotSupportedException("TGA files with interleaved images are not supported.");
if (header.Width == 0 || header.Height == 0)
throw new NotSupportedException("The TGA file is corrupt. Width and height are invalid.");
switch (header.ImageType)
{
case ImageType.TrueColor:
case ImageType.TrueColorRLE:
switch (header.BitsPerPixel)
{
case 16:
description.Format = DataFormat.B5G5R5A1_UNORM;
break;
case 24:
description.Format = DataFormat.R8G8B8A8_UNORM;
convFlags |= ConversionFlags.Expand;
// We could use DXGI_FORMAT_B8G8R8X8_UNORM, but we prefer DXGI 1.0 formats
break;
case 32:
description.Format = DataFormat.R8G8B8A8_UNORM;
// We could use DXGI.Format.B8G8R8A8_UNORM, but we prefer DXGI 1.0 formats
break;
}
if (header.ImageType == ImageType.TrueColorRLE)
convFlags |= ConversionFlags.RLE;
break;
case ImageType.BlackAndWhite:
case ImageType.BlackAndWhiteRLE:
switch (header.BitsPerPixel)
{
case 8:
description.Format = DataFormat.R8_UNORM;
break;
default:
throw new NotSupportedException("The black-and-white format used by the TGA file is not supported. Only 8-bit black-and-white images are supported.");
}
if (header.ImageType == ImageType.BlackAndWhiteRLE)
convFlags |= ConversionFlags.RLE;
break;
case ImageType.NoImage:
case ImageType.ColorMapped:
case ImageType.ColorMappedRLE:
throw new NotSupportedException("The image format used by the TGA file is not supported.");
default:
throw new InvalidDataException("Unknown image format used by the TGA file.");
}
description.Width = header.Width;
description.Height = header.Height;
description.Depth = 1;
description.MipLevels = 1;
description.ArraySize = 1;
if ((header.Descriptor & DescriptorFlags.InvertX) != 0)
convFlags |= ConversionFlags.InvertX;
if ((header.Descriptor & DescriptorFlags.InvertY) != 0)
convFlags |= ConversionFlags.InvertY;
offset = sizeOfTGAHeader;
if (header.IDLength != 0)
offset += header.IDLength;
return description;
}
public Stream ReadChunk(Stream ChunkStream, bool IncludeTheSize = false)
{
var ChunkLength = (int)(uint)ChunkStream.ReadStruct<uint_be>();
return ChunkStream.ReadStream(ChunkLength - (IncludeTheSize ? 4 : 0));
}
public Xex LoadHeader(Stream XexStream)
{
Header = XexStream.ReadStruct<HeaderStruct>();
var OptionalHeaders = XexStream.ReadStructVector<OptionalHeader>(Header.OptionalHeaderCount);
Console.WriteLine("{0:X}", XexStream.Position);
InfoList = new Dictionary<OptionalHeader.Ids, ulong>();
foreach (var OptionalHeader in OptionalHeaders)
{
//Console.WriteLine("{0}: 0x{1:X}", OptionalHeader.Id, (uint)OptionalHeader.Data);
//InfoList[OptionalHeader.Id] = OptionalHeader.Data;
InfoList.Add(OptionalHeader.Id, OptionalHeader.Data);
switch (OptionalHeader.Id)
{
case Xex.OptionalHeader.Ids.OriginalPEName:
this.OriginalPeName = LoadChunk(XexStream, OptionalHeader.Data).ReadStringz(Encoding: Encoding.UTF8);
break;
case Xex.OptionalHeader.Ids.LANKey:
this.LanKey = XexStream.SliceWithLength(OptionalHeader.Data, 0x10).ReadAll();
break;
case Xex.OptionalHeader.Ids.DefaultStackSize:
this.DefaultStackSize = OptionalHeader.Data;
break;
case Xex.OptionalHeader.Ids.ChecksumTimestamp:
this.ChecksumTimestamp = XexStream.SliceWithLength(OptionalHeader.Data).ReadStruct<ChecksumTimestampStruct>();
break;
case Xex.OptionalHeader.Ids.ImageBaseAddress:
this.ImageBaseAddress = OptionalHeader.Data;
break;
case Xex.OptionalHeader.Ids.EntryPoint:
this.EntryPoint = OptionalHeader.Data;
break;
case Xex.OptionalHeader.Ids.StaticLibraries:
this.StaticLibs = LoadChunk(XexStream, OptionalHeader.Data).ReadStructVectorUntilTheEndOfStream<StaticLib>();
foreach (var StaticLib in StaticLibs)
{
Console.WriteLine("StaticLib: {0}", StaticLib.ToStringDefault());
}
break;
case Xex.OptionalHeader.Ids.ImportLibraries:
{
var ImportLibrariesStream = LoadChunk(XexStream, OptionalHeader.Data);
var TextLength = (uint)ImportLibrariesStream.ReadStruct<uint_be>();
var LibraryCount = (uint)ImportLibrariesStream.ReadStruct<uint_be>();
var TextStream = ImportLibrariesStream.ReadStream(TextLength);
var LibraryNames = new String[LibraryCount];
for (int n = 0; n < LibraryCount; n++)
{
LibraryNames[n] = TextStream.ReadStringz(AllowEndOfStream: false);
Console.WriteLine("ImportLib: {0}", LibraryNames[n]);
}
var ChunkUnk1 = ReadChunkIncludingTheSize(ImportLibrariesStream);
var ImportAddressList = ReadChunkIncludingTheSize(ImportLibrariesStream);
Console.Error.WriteLine("@TODO: Xex.OptionalHeader.Ids.ImportLibraries");
}
break;
case Xex.OptionalHeader.Ids.TLSInfo:
{
this.TLSInfo = XexStream.SliceWithLength(OptionalHeader.Data).ReadStruct<TLSInfoStruct>();
}
break;
default:
Console.WriteLine("{0}: 0x{1:X}", OptionalHeader.Id, (uint)OptionalHeader.Data);
break;
}
}
PeStream = XexStream.SliceWithLength(Header.PeDataOffset);
Pe = new Pe().LoadHeader(PeStream);
Console.WriteLine("SecurityInfoOffset: {0:X}", (uint)Header.SecurityInfoOffset);
var SecurityStream = LoadChunk(XexStream, Header.SecurityInfoOffset);
var NumberOfSections = (ushort)SecurityStream.ReadStruct<ushort_be>();
Console.WriteLine("NumberOfSections: {0:X}", NumberOfSections);
return this;
}
