protected void ReadSectionNames(byte[] source)
{
for (int i = 0; i < SectionHeader.Length; i++)
{
SectionName[i] = ValueRead.ASCIIString(source, SectionHeader[i].sh_name);
if (NameMaxLength < SectionName[i].Length)
{
NameMaxLength = SectionName[i].Length;
}
}
}
protected virtual void ReadInfo(string filename)
{
ValueRead read = new ValueRead(Header.e_ident[(byte)EI.DataEncoding]);
FileStream fs;
for (int i = 0; i < Header.e_shnum; i++)
{
if (SectionHeader[i].sh_offset != 0)
{
if ((SectionHeader[i].sh_type & (uint)SHT_RPL.FILEINFO) == (uint)SHT_RPL.FILEINFO)
{
fs = File.Open(filename, FileMode.Open);
byte[] sectiondata = new byte[SectionHeader[i].sh_size];
fs.Position = SectionHeader[i].sh_offset;
fs.Read(sectiondata, 0, sectiondata.Length);
fs.Close();
Info = new RPX.FileInfo(sectiondata, 0, read);
if (Info.mSrcFileNameOffset != 0)
{
SrcFileName = ValueRead.ASCIIString(sectiondata, Info.mSrcFileNameOffset);
}
if (Info.mTagsOffset != 0)
{
ulong offset = Info.mTagsOffset;
string tag = ValueRead.ASCIIString(sectiondata, offset);
while (tag.Length != 0)
{
Tags.Add(tag);
offset += (ulong)tag.Length + 1;
tag = ValueRead.ASCIIString(sectiondata, offset);
}
}
}
else if ((SectionHeader[i].sh_type & (uint)SHT_RPL.CRCS) == (uint)SHT_RPL.CRCS)
{
fs = File.Open(filename, FileMode.Open);
byte[] sectiondata = new byte[SectionHeader[i].sh_size];
fs.Position = SectionHeader[i].sh_offset;
fs.Read(sectiondata, 0, sectiondata.Length);
fs.Close();
for (int j = 0; j < Header.e_shnum; j++)
{
CRC[j] = read.UInt32(sectiondata, (ulong)(j * 4));
}
}
}
}
}
public ELF64(string filename, bool readSectionHeaders)
: this()
{
FileStream fs = File.Open(filename, FileMode.Open);
byte[] ehdrBytes = new byte[64];
fs.Read(ehdrBytes, 0, ehdrBytes.Length);
fs.Close();
if (!(ehdrBytes[(byte)EI.MagicNumber0] == 0x7F &&
ehdrBytes[(byte)EI.MagicNumber1] == 'E' &&
ehdrBytes[(byte)EI.MagicNumber2] == 'L' &&
ehdrBytes[(byte)EI.MagicNumber3] == 'F'))
{
throw new FormatException("It is not an ELF file.");
}
else if (ehdrBytes[(byte)EI.FileClass] == (byte)EC.ELF32)
{
throw new FormatException("It is an ELF32 file.");
}
else if (ehdrBytes[(byte)EI.FileClass] != (byte)EC.ELF64)
{
throw new FormatException("It is an invalid ELF class.");
}
ValueRead read = new ValueRead(ehdrBytes[(byte)EI.DataEncoding]);
Header = new Elf64_Ehdr(ehdrBytes, read);
SectionHeader = new Elf64_Shdr[Header.e_shnum];
SectionName = new string[Header.e_shnum];
if (readSectionHeaders && SectionHeader.Length != 0)
{
fs = File.Open(filename, FileMode.Open);
byte[] shdrBytes = new byte[Header.e_shnum * Header.e_shentsize];
fs.Position = (long)Header.e_shoff;
fs.Read(shdrBytes, 0, shdrBytes.Length);
fs.Close();
SectionHeader = new Elf64_Shdr[Header.e_shnum];
for (int i = 0; i < Header.e_shnum; i++)
{
SectionHeader[i] = new Elf64_Shdr(shdrBytes, (uint)(Header.e_shentsize * i), read);
SectionName[i] = "";
}
}
}
public FileInfo(byte[] data, uint startIndex, ValueRead read)
{
magic_version = read.UInt32(data, startIndex + 0x00);
mRegBytes_Text = read.UInt32(data, startIndex + 0x04);
mRegBytes_TextAlign = read.UInt32(data, startIndex + 0x08);
mRegBytes_Data = read.UInt32(data, startIndex + 0x0c);
mRegBytes_DataAlign = read.UInt32(data, startIndex + 0x10);
mRegBytes_LoaderInfo = read.UInt32(data, startIndex + 0x14);
mRegBytes_LoaderInfoAlign = read.UInt32(data, startIndex + 0x18);
mRegBytes_Temp = read.UInt32(data, startIndex + 0x1c);
mTrampAdj = read.UInt32(data, startIndex + 0x20);
mSDABase = read.UInt32(data, startIndex + 0x24);
mSDA2Base = read.UInt32(data, startIndex + 0x28);
mSizeCoreStacks = read.UInt32(data, startIndex + 0x2c);
mSrcFileNameOffset = read.UInt32(data, startIndex + 0x30);
mFlags = read.UInt32(data, startIndex + 0x34);
mSysHeapBytes = read.UInt32(data, startIndex + 0x38);
mTagsOffset = read.UInt32(data, startIndex + 0x3c);
}
protected static byte[] Decompress(byte[] source)
{
uint decompressedSize = ValueRead.ReverseUInt32(source, 0);
uint adler32 = ValueRead.ReverseUInt32(source, (ulong)(source.Length - 4));
byte[] decompressedData = Security.ZlibDecompress(source, 4, source.Length - 4);
uint adler32Calculated = Security.Adler32(decompressedData, 0, decompressedData.Length);
if (decompressedSize != decompressedData.Length)
{
throw new FormatException("Decompressed size does not match.");
}
if (adler32 != adler32Calculated)
{
throw new FormatException("Adler-32 does not match.");
}
return(decompressedData);
}
public ROMInfo(byte[] data)
{
if (!(data[0x44] == 'W' &&
data[0x45] == 'U' &&
data[0x46] == 'P' &&
data[0x47] == '-'))
{
throw new FormatException("It is not an VC SNES ROM.");
}
HeaderData = new int[12];
HeaderData[0] = ValueRead.StandardInt32(data, 0x20); //Always 0x00000100
HeaderData[1] = ValueRead.StandardInt32(data, 0x24); //Size
HeaderData[2] = ValueRead.StandardInt32(data, 0x28); //ROM offset (Always 0x00000030)
HeaderData[3] = ValueRead.StandardInt32(data, 0x2C); //PCM samples offset
HeaderData[4] = ValueRead.StandardInt32(data, 0x30); //PCM footer offset
HeaderData[5] = ValueRead.StandardInt32(data, 0x34); //Footer offset
HeaderData[6] = ValueRead.StandardInt32(data, 0x38); //X0 offset
HeaderData[7] = ValueRead.StandardInt32(data, 0x3C); //X1 offset
HeaderData[8] = ValueRead.StandardInt32(data, 0x40); //X2 offset
HeaderData[9] = ValueRead.StandardInt32(data, 0x44); //Always 0x2D505557 ("WUP-")
HeaderData[10] = ValueRead.StandardInt32(data, 0x48); //Product code
HeaderData[11] = ValueRead.StandardInt32(data, 0x4C); //Always 0x00000000
if (data[0x31 + HeaderData[5]] == 0x14 || data[0x31 + HeaderData[5]] == 0x15)
{
FooterData = new byte[19];
}
else
{
FooterData = new byte[16];
}
FooterData[0] = data[0x20 + HeaderData[5]]; //Emulation speed (Always 0x3C (60 FPS))
FooterData[1] = data[0x21 + HeaderData[5]]; //ROM size byte 0
FooterData[2] = data[0x22 + HeaderData[5]]; //ROM size byte 1
FooterData[3] = data[0x23 + HeaderData[5]]; //ROM size byte 2
FooterData[4] = data[0x24 + HeaderData[5]]; //ROM size byte 3
FooterData[5] = data[0x25 + HeaderData[5]]; //PCM samples size byte 0
FooterData[6] = data[0x26 + HeaderData[5]]; //PCM samples size byte 1
FooterData[7] = data[0x27 + HeaderData[5]]; //PCM samples size byte 2
FooterData[8] = data[0x28 + HeaderData[5]]; //PCM samples size byte 3
FooterData[9] = data[0x29 + HeaderData[5]]; //PCM footer size byte 0
FooterData[10] = data[0x2A + HeaderData[5]]; //PCM footer size byte 1
FooterData[11] = data[0x2B + HeaderData[5]]; //PCM footer size byte 2
FooterData[12] = data[0x2C + HeaderData[5]]; //PCM footer size byte 3
FooterData[13] = data[0x2D + HeaderData[5]]; //Game preset ID byte 0
FooterData[14] = data[0x2E + HeaderData[5]]; //Game preset ID byte 1
FooterData[15] = data[0x2F + HeaderData[5]]; //Amount of players
if (FooterData.Length == 19)
{
FooterData[16] = data[0x30 + HeaderData[5]]; //Sound volume
FooterData[17] = data[0x31 + HeaderData[5]]; //ROM type (0x14 LoROM, 0x15 HiROM)
FooterData[18] = data[0x32 + HeaderData[5]]; //Enhancement chip
//0x00 Normal
//0x02 DSP-1
//0x03 S-DD1
//0x04 Cx4
//0x05 ??? (DSP-2?)
//0x06 SA-1
//0x07 SA-1
//0x08 SA-1
//0x09 SA-1
//0x0A SA-1
//0x0B SA-1
//0x0C SuperFX/GSU
}
ExtraData = new byte[HeaderData[1] - (HeaderData[5] + FooterData.Length)];
for (int i = 0; i < ExtraData.Length; i++)
{
ExtraData[i] = data[0x20 + HeaderData[5] + FooterData.Length + i];
}
FormatCode = (char)data[0x48];
ShortID = ValueRead.ASCIIString(data, 0x49, 2);
RegionCode = (char)data[0x4B];
RawSize = ValueRead.StandardInt32(data, (ulong)(0x21 + HeaderData[5]));
PCMSamplesSize = ValueRead.StandardInt32(data, (ulong)(0x25 + HeaderData[5]));
PCMFooterSize = ValueRead.StandardInt32(data, (ulong)(0x29 + HeaderData[5]));
Data = new byte[RawSize];
Array.Copy(data, 0x20 + HeaderData[2], Data, 0, Data.Length);
AdditionalData = new byte[data.Length - 0x20 - HeaderData[1]];
Array.Copy(data, 0x20 + HeaderData[1], AdditionalData, 0, AdditionalData.Length);
}
