public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { UInt64 offset = file.FileStartOffset; if (System.IO.Path.GetExtension(file.Filename).ToUpper() != ".PSP") { return(null); } if ((fileReader.Read_32bitsBE(offset) != 0x01000010) && (fileReader.Read_32bitsBE(offset) != 0x434C5500)) { return(null); } FST tmpFST = new FST(); uint fileCount = (uint)fileReader.Read_32bits(offset + 0x0C); uint bufferSize = (uint)fileReader.Read_32bits(offset + 0x08); byte[] buffer = fileReader.Read(offset + 0x20, bufferSize); for (uint i = 0; i < fileCount; i++) { uint fileOffset = MemoryReader.ReadLong(ref buffer, (i * 0x10) + 0x08); uint fileSize = MemoryReader.ReadLong(ref buffer, (i * 0x10) + 0x04); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, string.Empty, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } return(tmpFST); }
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength) { bool loop_flag = (fileReader.Read_32bits(offset + 0x1C) != 0xFFFFFFFF); int channel_count = (int)fileReader.Read_32bits(offset + 0x10); int sample_rate = (int)fileReader.Read_32bits(offset + 0x0c); /* build the VGMSTREAM */ VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag); vgmStream.vgmLoopFlag = loop_flag; vgmStream.vgmChannelCount = channel_count; vgmStream.vgmSampleRate = sample_rate; vgmStream.vgmTotalSamples = (int)fileReader.Read_32bits(offset + 0x24) / 16 * 28 / channel_count; vgmStream.vgmLayout = new Interleave(); vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bits(offset + 0x14); vgmStream.vgmDecoder = new PSX_Decoder(); if (loop_flag) { vgmStream.vgmLoopStartSample = ((int)fileReader.Read_32bits(offset + 0x18) * 0x10) / 16 * 28 / vgmStream.vgmChannelCount; vgmStream.vgmLoopEndSample = ((int)fileReader.Read_32bits(offset + 0x1C) * 0x10) / 16 * 28 / vgmStream.vgmChannelCount; if (vgmStream.vgmLoopEndSample > vgmStream.vgmTotalSamples) { vgmStream.vgmLoopStartSample = ((int)fileReader.Read_32bits(offset + 0x18)) / 16 * 28 / vgmStream.vgmChannelCount; vgmStream.vgmLoopEndSample = ((int)fileReader.Read_32bits(offset + 0x1C)) / 16 * 28 / vgmStream.vgmChannelCount; } } UInt64 start_offset = offset + 0x28; if (!VGM_Utils.IsPS2ADPCM(fileReader, start_offset, start_offset + 0x8000)) { start_offset = offset + 0x800; if (!VGM_Utils.IsPS2ADPCM(fileReader, start_offset, start_offset + 0x8000)) { start_offset = offset + 0x28; vgmStream.vgmDecoder = new PCM16_Decoder(); vgmStream.vgmDecoderType = VGM_Decoder_Type.PCM16BITS; vgmStream.vgmTotalSamples = (int)fileReader.Read_32bits(offset + 0x24) / 2 / channel_count; if (loop_flag) { vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bits(offset + 0x18); vgmStream.vgmLoopEndSample = (int)fileReader.Read_32bits(offset + 0x1C); } } } if (InitReader) { for (int i = 0; i < channel_count; i++) { vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());; vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename()); vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID()); vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i); } } }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("RIFF") if (fileReader.Read_32bitsBE(offset) != 0x52494646) { return(0); } if (!((fileReader.Read_32bits(offset + 0x20) % 0x40) == 0)) { return(0); } // Check for Mark ID ("WAVE" + "fmt ") if ((fileReader.Read_32bitsBE(offset + 0x08) == 0x57415645) && (fileReader.Read_32bitsBE(offset + 0x0C) == 0x666D7420)) { if ((fileReader.Read_16bits(offset + 0x14) == 0xFFFE) || (fileReader.Read_16bits(offset + 0x14) == 0xFFFC)) { if (VGM_Utils.CheckSampleRate(fileReader.Read_16bits(offset + 0x18))) { length = fileReader.Read_32bits(offset + 0x04) + 0x8; return(length); } } } return(0); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("SShd") if (fileReader.Read_32bitsBE(offset) != 0x53536864) { return(0); } // Check for Mark ID ("SSbd") if (fileReader.Read_32bitsBE(offset + 0x20) != 0x53536264) { return(0); } uint channel_count = fileReader.Read_32bits(offset + 0x10); uint sample_rate = fileReader.Read_32bits(offset + 0x0c); if (!VGM_Utils.CheckChannels(channel_count)) { return(0); } if (!VGM_Utils.CheckSampleRate(sample_rate)) { return(0); } uint fileLength = fileReader.Read_32bits(offset + 0x024); return(fileLength + 0x28); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { UInt64 nextOffset = 0; UInt64 endOffset = offset + length; // Check for Mark ID ("CAF ") if (fileReader.Read_32bitsBE(offset) != 0x43414620) { return(0); } uint blockCount = fileReader.Read_32bitsBE(offset + 0x24) - 1; for (int i = 0; i < blockCount; i++) { nextOffset = fileReader.Read_32bitsBE(offset + 0x4); if (fileReader.Read_32bitsBE(offset) != 0x43414620) { return(0); } if (fileReader.Read_32bitsBE(offset + 0x08) != i) { return(0); } offset += nextOffset; } return(length); }
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength) { bool loop_flag = (fileReader.Read_32bits(offset + 0x14) == 1); int channel_count = (int)fileReader.Read_32bits(offset + 0x0C); if (fileReader.Read_32bits(offset + 0x30) == 0x45434B2E) { m_Description = "Konami SVAG (KCE-Tokyo)"; } else { m_Description = "Konami SVAG (KONAMITYO)"; } /* build the VGMSTREAM */ VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag); /* fill in the vital statistics */ UInt64 start_offset = offset + 0x800; vgmStream.vgmChannelCount = channel_count; vgmStream.vgmSampleRate = (int)fileReader.Read_32bits(offset + 0x08); vgmStream.vgmDecoder = new PSX_Decoder(); if (vgmStream.vgmChannelCount == 1) { vgmStream.vgmLayout = new NoLayout(); } else { vgmStream.vgmLayout = new Interleave(); } vgmStream.vgmLoopFlag = loop_flag; vgmStream.vgmTotalSamples = (int)((fileReader.Read_32bits(offset + 0x04) * 28 / 16) / channel_count); if (loop_flag) { vgmStream.vgmLoopStartSample = (int)(fileReader.Read_32bits(offset + 0x18) / 16 * 28); vgmStream.vgmLoopEndSample = (int)(fileReader.Read_32bits(offset + 0x04) / 16 * 28 / vgmStream.vgmChannelCount); } vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bits(offset + 0x10); if (InitReader) { for (int i = 0; i < channel_count; i++) { vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());; vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename()); vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i); } } }
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength) { int vgmNumSamples = 0; int loop_start = -1; UInt64 NextBlock; UInt64 currBlock = offset; int i; // Calculate sample length ... uint blockCount = fileReader.Read_32bitsBE(offset + 0x24); for (i = 0; i < blockCount; i++) { NextBlock = fileReader.Read_32bitsBE(currBlock + 0x04); vgmNumSamples += (int)(fileReader.Read_32bitsBE(currBlock + 0x14) / 8 * 14); if (fileReader.Read_32bitsBE(currBlock + 0x20) == fileReader.Read_32bitsBE(currBlock + 0x08)) { loop_start = (int)(vgmNumSamples - fileReader.Read_32bitsBE(currBlock + 0x14) / 8 * 14); } currBlock += NextBlock; } bool loop_flag = (loop_start != -1); /* build the VGMSTREAM */ VGM_Utils.allocate_vgmStream(ref vgmStream, 2, loop_flag); vgmStream.vgmLoopFlag = loop_flag; vgmStream.vgmChannelCount = 2; vgmStream.vgmSampleRate = 32000; vgmStream.vgmTotalSamples = vgmNumSamples; if (loop_flag) { vgmStream.vgmLoopStartSample = loop_start; vgmStream.vgmLoopEndSample = vgmNumSamples; } vgmStream.vgmDecoder = new DSP_Decoder(); vgmStream.vgmLayout = new Blocked(); vgmStream.vgmLayoutType = VGM_Layout_Type.CAF_Blocked; if (InitReader) { for (i = 0; i < 2; i++) { vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());; vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename()); vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID()); } BlockedFnts.CAF_Block_Update(offset + 0, ref vgmStream); } }
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength) { Int16[] coef = new Int16[16] { 0x04ab, -0x0313, 0x0789, -0x0121, 0x09a2, -0x051b, 0x0c90, -0x053f, 0x084d, -0x055c, 0x0982, -0x0209, 0x0af6, -0x0506, 0x0be6, -0x040b }; int channel_count = fileReader.Read_8Bits(offset + 0x16); /* build the VGMSTREAM */ VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, false); vgmStream.vgmDecoder = new DSP_Decoder(); vgmStream.vgmLayout = new Interleave(); vgmStream.vgmChannelCount = channel_count; vgmStream.vgmLoopFlag = false; vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bits(offset + 0x42) / 8 * 14) / channel_count; vgmStream.vgmSampleRate = fileReader.Read_16bits(offset + 0x18); if (channel_count == 1) { vgmStream.vgmLayout = new NoLayout(); } else { vgmStream.vgmLayout = new Interleave(); vgmStream.vgmLayoutType = VGM_Layout_Type.Interleave_With_Shortblock; } vgmStream.vgmInterleaveBlockSize = 0x08; int i, j; for (j = 0; j < vgmStream.vgmChannelCount; j++) { for (i = 0; i < 16; i++) { vgmStream.vgmChannel[j].adpcm_coef[i] = coef[i]; } } UInt64 start_offset = offset + 0x46; if (InitReader) { for (i = 0; i < channel_count; i++) { vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());; vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename()); vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID()); vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(i * vgmStream.vgmInterleaveBlockSize); } } }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; // check for ARC marker if ((fileReader.Read_32bitsBE(offset) != 0x41524300)) { return(null); } //string archiveName = fileReader.Read_String(offset + 0x08, 0x50); uint fileCount = (uint)fileReader.Read_32bits(offset + 0x0C); uint offset_adding = (uint)fileReader.Read_32bits(offset + 0x18); uint offset_name = (uint)fileReader.Read_32bits(offset + 0x10); if ((offset_adding == 0) || (offset_adding > file.FileSize)) { return(null); } if ((offset_name == 0) || (offset_name > offset_adding)) { return(null); } byte[] buffer_name = fileReader.Read(offset + offset_name, offset_adding - offset_name); // long filenameOffset = fileReader.Read_32bits(offset + 0x08 + (fileCount * 8)); // if (filenameOffset != 0) //{ // uint filenameSize = fileReader.Read_32bits(offset + 0x08 + (fileCount * 8) + 4); // filenameBuffer = fileReader.Read(offset + filenameOffset, filenameSize); //} for (uint i = 0; i < fileCount; i++) { UInt64 fileOffset = MemoryReader.ReadLong(ref buffer_name, (i * 0x18)); uint fileSize = MemoryReader.ReadLong(ref buffer_name, (i * 0x18) + 0x04); string filename = string.Empty; if (fileOffset != 0) { fileOffset += offset_adding; uint filenameOffset = MemoryReader.ReadLong(ref buffer_name, (i * 0x18) + 0x10); filename = MemoryReader.GetString(ref buffer_name, (fileCount * 0x18) + filenameOffset, 0xff); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } } return(tmpFST); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; uint offsetBuffer = 0; bool bigEndian = true; // check for BIGF marker if (fileReader.Read_32bitsBE(offset) != 0x42494746) { return(null); } if (fileReader.Read_32bitsBE(offset + 4) == file.FileSize) { bigEndian = false; } uint fileCount, filenameSize, fileOffset, fileSize; if (bigEndian) { fileCount = (uint)fileReader.Read_32bits(offset + 0x08); filenameSize = fileReader.Read_32bits(offset + 0x0C) - 0x10; } else { fileCount = (uint)fileReader.Read_32bitsBE(offset + 0x08); filenameSize = fileReader.Read_32bitsBE(offset + 0x0C) - 0x10; } byte[] buffer = fileReader.Read(offset + 0x10, filenameSize); for (uint i = 0; i < fileCount; i++) { if (bigEndian) { fileOffset = MemoryReader.ReadLong(ref buffer, offsetBuffer); fileSize = MemoryReader.ReadLong(ref buffer, offsetBuffer + 4); } else { fileOffset = MemoryReader.ReadLongBE(ref buffer, offsetBuffer); fileSize = MemoryReader.ReadLongBE(ref buffer, offsetBuffer + 4); } string filename = string.Empty; filename = MemoryReader.GetString(ref buffer, offsetBuffer + 8); offsetBuffer += (uint)(8 + 1 + filename.Length); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } return(tmpFST); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { if (fileReader.Read_32bitsBE(offset + 0) != 0x5253544D) /* "RSTM" */ { return(0); } if ((fileReader.Read_32bitsBE(offset + 0x04) != 0xFEFF0100) && (fileReader.Read_32bitsBE(offset + 0x04) != 0xFEFF0001)) { return(0); } /* get head offset, check */ UInt64 head_offset = fileReader.Read_16bitsBE(offset + 0x0C); if (head_offset == 0x10) { m_Description = "Nintendo RSTM Header v1"; } else { m_Description = "Nintendo RSTM Header v2"; } UInt64 rl_head_offset = head_offset + offset; if (fileReader.Read_32bitsBE(head_offset + offset) != 0x48454144) /* "HEAD" */ { return(0); } /* check type details */ byte codec_number = fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0x8 : rl_head_offset + 0x20); bool loop_flag = (fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0x19 : rl_head_offset + 0x21) != 0); uint channel_count = fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0xa : rl_head_offset + 0x22); uint sample_rate = fileReader.Read_16bitsBE((head_offset == 0x10) ? rl_head_offset + 0xc : rl_head_offset + 0x24); if (!VGM_Utils.CheckChannels(channel_count)) { return(0); } if (!VGM_Utils.CheckSampleRate(sample_rate)) { return(0); } if (codec_number > 2) { return(0); } return(fileReader.Read_32bitsBE(offset + 0x08)); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; // check for AFS marker if (!((fileReader.Read_32bitsBE(offset) == 0x48473200) && (fileReader.Read_32bitsBE(offset + 4) == 0x03000000) && (fileReader.Read_32bitsBE(offset + 8) == 0x02000000))) { return(null); } //string archiveName = fileReader.Read_String(offset + 0x08, 0x50); uint sizeOfEntireFile = fileReader.Read_32bits(offset + 0x0c); if ((sizeOfEntireFile == 0) || (sizeOfEntireFile > file.FileSize)) { return(null); } uint fileCount = (uint)fileReader.Read_32bits(offset + 0x20); uint offsetOfFilename = (uint)fileReader.Read_32bits(offset + 0x2C); uint offsetOfFileInfo = (uint)fileReader.Read_32bits(offset + 0x24); byte[] buffer = fileReader.Read(offset + offsetOfFileInfo, (fileCount * 0x0c)); byte[] bufferOffsetName = fileReader.Read(offset + offsetOfFilename, (fileCount * 0x04)); uint OffsetSubstract = MemoryReader.ReadLong(ref bufferOffsetName, 0); if (OffsetSubstract > sizeOfEntireFile) { return(null); } byte[] bufferFileName = fileReader.Read(offset + offsetOfFilename + (fileCount * 0x04), sizeOfEntireFile - OffsetSubstract); for (uint i = 0; i < fileCount; i++) { uint fileOffset = MemoryReader.ReadLong(ref buffer, (i * 0x0c) + 0x08); uint fileSize = MemoryReader.ReadLong(ref buffer, (i * 0x0c) + 0x04); string filename = string.Empty; uint OffsetofFilename = MemoryReader.ReadLong(ref bufferOffsetName, (i * 0x04)); filename = MemoryReader.GetString(ref bufferFileName, OffsetofFilename - OffsetSubstract, 0x255); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } return(tmpFST); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { if (System.IO.Path.GetExtension(file.Filename).ToUpper() != ".AWB") { return(null); } byte[] filenameBuffer = null; FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; UInt64 readOffset = offset; // check for AFS2 marker if (!((fileReader.Read_32bitsBE(readOffset) == 0x41465332) && (fileReader.Read_32bitsBE(readOffset + 0x04) == 0x01040200))) { return(null); } uint fileCount = (uint)fileReader.Read_32bits(readOffset + 0x08); readOffset += 0x10; readOffset += fileCount * 2; uint fileOffset = (uint)fileReader.Read_32bits(readOffset); readOffset += 4; byte[] buffer = fileReader.Read(readOffset, (fileCount * 4)); for (uint i = 0; i < fileCount; i++) { uint nextOffset = MemoryReader.ReadLong(ref buffer, (i * 8)); uint fileSize; uint padding = (fileOffset / 0x10) * 0x10; padding -= fileOffset; padding += 0x10; fileOffset += padding; fileSize = nextOffset; fileSize -= fileOffset; string filename = string.Empty; tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); fileOffset = nextOffset; } return(tmpFST); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { FST tmpFST = new FST(); if (!((System.IO.Path.GetExtension(file.Filename).ToUpper() == ".PSARC") || (System.IO.Path.GetExtension(file.Filename).ToUpper() == ".PAC"))) { return(null); } UInt64 offset = file.FileStartOffset; while (offset <= file.FileSize) { // check for FPAC marker if (fileReader.Read_32bitsBE(offset) == 0x46504143) { uint sizeofInfo = fileReader.Read_32bits(offset + 0x04); byte[] buffer = fileReader.Read(offset, sizeofInfo); uint sizeofFile = MemoryReader.ReadLong(ref buffer, 0x08); uint fileCount = MemoryReader.ReadLong(ref buffer, 0x0c); uint offsetofIndex = MemoryReader.ReadLong(ref buffer, 0x10); uint offsetofInfo = MemoryReader.ReadLong(ref buffer, 0x14); if (fileCount != 0) { uint sizeofOneInfo = 0; sizeofOneInfo = (sizeofInfo - 0x20) / fileCount; for (uint i = 0; i < fileCount; i++) { uint fileSize = MemoryReader.ReadLong(ref buffer, (i * sizeofOneInfo) + offsetofInfo + 0x20 + 8); uint fileOffset = MemoryReader.ReadLong(ref buffer, (i * sizeofOneInfo) + offsetofInfo + 0x20 + 4) + sizeofInfo; string filename = string.Empty; filename = MemoryReader.GetString(ref buffer, (i * sizeofOneInfo) + 0x20, offsetofInfo); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } } offset += sizeofFile; } else { offset += 4; } } return(tmpFST); }
public VGM_Decoding(VGM_Stream vgmStream, StreamReader.IReader fileReader) { m_vgmStream = vgmStream; m_fileReader = fileReader; if (m_WavFormat != null) { m_WavFormat = null; } m_WavFormat = new NAudio.Wave.WaveFormat(vgmStream.vgmSampleRate, vgmStream.vgmChannelCount); m_FadeSamples = (int)(m_FadeSeconds * vgmStream.vgmSampleRate); m_vgmStream.vgmDecodedSamples = 0; m_vgmStream.vgmTotalSamplesWithLoop = VGM_Utils.get_vgmstream_play_samples(2, m_FadeSeconds, 0, vgmStream); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { if (System.IO.Path.GetExtension(file.Filename).ToUpper() != ".PAK") { return(null); } FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; // check for marker ID if ((fileReader.Read_16bits(offset + 0x0A) != 0xA3DA)) { return(null); } uint fileCount = (uint)fileReader.Read_32bits(offset + 0x08) ^ 0xa3da79b6; uint filenameSize = fileReader.Read_32bits(offset + 0x0C); uint folderNameSize = fileReader.Read_32bits(offset + 0x10); byte[] folderName = fileReader.Read(offset + 0x14, folderNameSize); for (int i = 0; i < folderNameSize; i++) { folderName[i] = (byte)(folderName[i] ^ 0xC5); } string folder = MemoryReader.GetString(ref folderName, 0); byte[] buffer = fileReader.Read(offset + 0x14 + folderNameSize + 1, (fileCount * 0x10)); byte[] bufferName = fileReader.Read(offset + 0x14 + folderNameSize + 1 + (fileCount * 0x10), filenameSize); for (int i = 0; i < filenameSize; i++) { bufferName[i] = (byte)(bufferName[i] ^ 0xB5); } for (uint i = 0; i < fileCount; i++) { uint fileNameOffset = MemoryReader.ReadLong(ref buffer, (i * 0x10)); uint fileOffset = MemoryReader.ReadLong(ref buffer, (i * 0x10) + 0x04); uint fileSize = MemoryReader.ReadLong(ref buffer, (i * 0x10) + 0x08); string filename = string.Empty; filename = MemoryReader.GetString(ref bufferName, fileNameOffset); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } return(tmpFST); }
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength) { int i; bool loop_flag = (fileReader.Read_32bits(offset + 0x14) != 0); int channel_count = (int)fileReader.Read_32bits(offset + 0x1C); /* build the VGMSTREAM */ VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag); /* fill in the vital statistics */ UInt64 start_offset = offset + fileReader.Read_32bits(offset + 0x08); vgmStream.vgmChannelCount = channel_count; vgmStream.vgmSampleRate = (int)fileReader.Read_32bits(offset + 0x18); vgmStream.vgmDecoder = new PSX_Decoder(); if (channel_count == 1) { vgmStream.vgmLayout = new NoLayout(); } else { vgmStream.vgmLayout = new Interleave(); } vgmStream.vgmLoopFlag = loop_flag; vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bits(offset + 0x0C) * 28 / 16 / channel_count); if (loop_flag) { vgmStream.vgmLoopStartSample = (int)((fileReader.Read_32bits(offset + 0x0C) - fileReader.Read_32bits(offset + 0x14)) * 28 / 16 / channel_count); vgmStream.vgmLoopEndSample = (int)(fileReader.Read_32bits(offset + 0x0C) * 28 / 16 / channel_count); } vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bits(offset + 0x24); if (InitReader) { for (i = 0; i < channel_count; i++) { vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());; vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename()); vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i); } } }
/// <summary> /// Test if the current block contains PS2 ADPCM /// </summary> /// <param name="Reader">StreamReader.IReader Class</param> /// <param name="StartOffset">Start offset of the block</param> /// <param name="EndOffset">End offset of the block</param> /// <returns>True if all the block contains PS2 ADPCM</returns> public static bool IsPS2ADPCM(StreamReader.IReader Reader, UInt64 StartOffset, UInt64 EndOffset) { byte[] buffer = new byte[0x10]; UInt64 offset = StartOffset; do { buffer = Reader.Read(offset, 0x10); offset += 0x10; if ((HINIBBLE(buffer[0]) > 5) || ((LONIBBLE(buffer[0])) > 0xC) || (buffer[1] > 7)) { return(false); } } while (offset < EndOffset); return(true); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { if (System.IO.Path.GetExtension(file.Filename).ToUpper() != ".XAD") { return(null); } byte[] filenameBuffer = null; FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; // check for AFS marker if ((fileReader.Read_32bitsBE(offset + 0x10) != 0x58444100) && (fileReader.Read_32bitsBE(offset + 0x14) != 0x82000000)) { return(null); } //string archiveName = fileReader.Read_String(offset + 0x08, 0x50); uint fileCount = fileReader.Read_32bits(offset + 0x04); byte[] buffer = fileReader.Read(offset + 0x08, (fileCount * 8)); UInt64 filenameOffset = fileReader.Read_32bits(offset + 0x08 + (fileCount * 8)); if (filenameOffset != 0) { uint filenameSize = fileReader.Read_32bits(offset + 0x08 + (fileCount * 8) + 4); filenameBuffer = fileReader.Read(offset + filenameOffset, filenameSize); } for (uint i = 0; i < fileCount; i++) { uint fileOffset = MemoryReader.ReadLong(ref buffer, (i * 8)); uint fileSize = MemoryReader.ReadLong(ref buffer, (i * 8) + 0x04); string filename = string.Empty; if (filenameOffset != 0) { filename = MemoryReader.GetString(ref filenameBuffer, (i * 0x30), 0x20); } tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } return(tmpFST); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("Svag") if (fileReader.Read_32bitsBE(offset) != 0x53766167) { return(0); } // Check for Sample Rate if (!VGM_Utils.CheckSampleRate(fileReader.Read_32bits(offset + 0x08))) { return(0); } // Check Channels count if (!VGM_Utils.CheckChannels(fileReader.Read_32bits(offset + 0x0C))) { return(0); } // Values from 0 -> 0x1C are duplicated at offset 0x400 for (UInt64 i = 0; i < 0x1C / 4; i++) { if (fileReader.Read_32bits(offset + i) != fileReader.Read_32bits(offset + 0x400 + i)) { return(0); } } // Try to find file Length UInt64 startOffset = 0x800; UInt64 fileLength = fileReader.Read_32bits(offset + 0x04); //if (!VGM_Utils.IsPS2ADPCM(fileReader, startOffset + offset, startOffset + offset + fileLength)) // return 0; if (fileReader.Read_32bits(offset + 0x30) == 0x45434B2E) { m_Description = "Konami SVAG (KCE-Tokyo)"; } else { m_Description = "Konami SVAG (KONAMITYO)"; } return(fileLength + startOffset); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("NPSF") if (fileReader.Read_32bitsBE(offset) != 0x4E505346) { return(0); } uint channel_count = fileReader.Read_32bits(offset + 0x0C); uint sample_rate = fileReader.Read_32bits(offset + 0x18); if (!VGM_Utils.CheckChannels(channel_count)) { return(0); } if (!VGM_Utils.CheckSampleRate(sample_rate)) { return(0); } if (fileReader.Read_32bits(offset + 0x10) != 0x800) { return(0); } uint fileLength = fileReader.Read_32bits(offset + 0x08); m_Filename = fileReader.Read_String(offset + 0x34, 0x20); if (channel_count == 1) { return(fileLength + 0x800); } else { uint blockCount = fileLength / 0x800; if ((fileLength % 0x800) != 0) { blockCount++; } fileLength = (blockCount * channel_count * 0x800) + 0x800; } return(fileLength); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("VAGx") where x can be "p","i","s" if ((fileReader.Read_32bitsBE(offset) & 0xFFFFFF00) != 0x56414700) { return(0); } uint vagLength = fileReader.Read_32bitsBE(offset + 0x0C) + 0x30; if (fileReader.Read_32bitsBE(offset + 0x24) == 0x56414778) { uint k = 0; do { k += 0x10; vagLength += 0x10; }while (fileReader.Read_16bitsBE(offset + fileReader.Read_32bitsBE(offset + 0x0C) + k) != 0x0007); } if ((length != (UInt64)(0xFFFFFFFFF)) && (vagLength != length)) { return(0); } // Check for Sample Rate if (!VGM_Utils.CheckSampleRate(fileReader.Read_32bitsBE(offset + 0x10))) { return(0); } if (!VGM_Utils.IsPS2ADPCM(fileReader, offset + 0x30, offset + vagLength)) { return(0); } // Filename is stored at offset +0x20 m_Filename = fileReader.Read_String(offset + 0x20, 0x10); return(vagLength + 0x30); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("STER") if (fileReader.Read_32bitsBE(offset) != 0x53544552) { return(0); } // 0x04 = Length of each channels in byte // 0x08 = Length of each channels in byte (in Little Endian Format) if (fileReader.Read_32bits(offset + 0x04) != fileReader.Read_32bitsBE(offset + 0x0C)) { return(0); } // Check for Sample Rate uint sampleRate = fileReader.Read_32bitsBE(offset + 0x10); if ((sampleRate < 11025) || (sampleRate > 48000)) { return(0); } // others data must be equal to 0 if ((fileReader.Read_32bits(offset + 0x14) != 0) || (fileReader.Read_32bits(offset + 0x18) != 0) || (fileReader.Read_32bits(offset + 0x1C) != 0)) { return(0); } // Try to find file Length UInt64 startOffset = 0x30; UInt64 fileLength = fileReader.Read_32bits(offset + 0x04) * 2; //if (!VGM_Utils.IsPS2ADPCM(fileReader, startOffset + offset, startOffset + offset + fileLength)) // return 0; // Filename is stored at offset +0x20 m_Filename = fileReader.Read_String(offset + 0x20, 0x10); return(fileLength + startOffset); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("THP") if (fileReader.Read_32bitsBE(offset) != 0x54485000) { return(0); } // check if thp is correct ... //if (fileReader.Read_32bitsBE(offset + 0x1C) + 0x60 != length) // return 0; // check if thp has audio if (fileReader.Read_32bitsBE(offset + 0x0C) == 0) { return(0); } return(length); }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("PSMF") if (fileReader.Read_32bitsBE(offset) != 0x50534D46) { return(0); } if ((fileReader.Read_32bitsBE(offset + 0x04) == 0x30303135) || (fileReader.Read_32bitsBE(offset + 0x04) == 0x30303132) || (fileReader.Read_32bitsBE(offset + 0x04) == 0x30303134)) { length = fileReader.Read_32bitsBE(offset + 0x0C) + 0x800; return(length); } else { return(0); } }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID if (fileReader.Read_32bitsBE(offset) != 0x01006408) { return(0); } // Check for Start Offset Value (can't be equal to 0) if (fileReader.Read_32bits(offset + 8) == 0) { return(0); } // Check for Channels Count & Sample Rate uint sampleRate = fileReader.Read_32bits(offset + 0x18); uint channelCount = fileReader.Read_32bits(offset + 0x1C); uint interleave = fileReader.Read_32bits(offset + 0x24); if (((channelCount <= 0) || (channelCount > 2)) || ((sampleRate < 11025) || (sampleRate > 48000))) { return(0); } // Check for Interleave value if ((interleave < 0) || (interleave > 0x10000)) { return(0); } // Try to find file Length UInt64 startOffset = fileReader.Read_32bits(offset + 0x08); UInt64 fileLength = fileReader.Read_32bits(offset + 0x0C); //if (!VGM_Utils.IsPS2ADPCM(fileReader, startOffset + offset, startOffset + offset + fileLength)) // return 0; return(fileLength + startOffset); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { if (System.IO.Path.GetExtension(file.Filename).ToUpper() != ".PAC") { return(null); } FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; // check for AFS marker if (!((fileReader.Read_32bitsBE(offset) == 0x44474b50) && (fileReader.Read_32bitsBE(offset + 4) == 0x00000100))) { return(null); } uint fileCount = (uint)fileReader.Read_32bits(offset + 0x0C); uint offsetStart = (uint)fileReader.Read_32bits(offset + 0x10); uint fileOffset = offsetStart; for (uint i = 0; i < fileCount; i++) { byte[] buffer = fileReader.Read(offset + fileOffset, 0x90); if (MemoryReader.ReadLongBE(ref buffer, 0) == 0x53415439) { fileOffset += 0x90; uint fileSize = MemoryReader.ReadLong(ref buffer, 0x08); string filename = string.Empty; filename = MemoryReader.GetString(ref buffer, 0x10); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.FileOwner, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } fileOffset += (uint)MemoryReader.ReadLong(ref buffer, 0x08); } return(tmpFST); }
public FST IsContainer(StreamReader.IReader fileReader, FST.cFile file, int index) { FST tmpFST = new FST(); UInt64 offset = file.FileStartOffset; // check for file extension ".POD" if (System.IO.Path.GetExtension(file.Filename).ToUpper() != ".POD") { return(null); } // check for POD2 marker if (fileReader.Read_32bitsBE(offset) != 0x504F4432) { return(null); } string archiveName = fileReader.Read_String(offset + 0x08, 0x50); uint fileCount = fileReader.Read_32bits(offset + 0x58); uint filenameOffset = 0x60 + (fileCount * 20); uint filenameSize = fileReader.Read_32bits(offset + 0x68) - filenameOffset; byte[] buffer = fileReader.Read(offset + 0x60, (fileCount * 20)); byte[] filenameBuffer = fileReader.Read(offset + filenameOffset, filenameSize); for (uint i = 0; i < fileCount; i++) { uint nameOffset = MemoryReader.ReadLong(ref buffer, (i * 20)); uint fileSize = MemoryReader.ReadLong(ref buffer, (i * 20) + 0x04); uint fileOffset = MemoryReader.ReadLong(ref buffer, (i * 20) + 0x08); string filename = MemoryReader.GetString(ref filenameBuffer, nameOffset); tmpFST.FST_File.Add(new FST.cFile(file.SessionID, (uint)index, 0, filename, file.Filename, file.FilePath, offset + fileOffset, fileSize, tmpFST.EmptyDateTime, false)); } return(tmpFST); }
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength) { bool loop_flag = (fileReader.Read_32bits(offset + 0x7FC) != 0); int channel_count = (int)fileReader.Read_32bits(offset + 0x14); int sample_rate = (int)fileReader.Read_32bits(offset + 0x10); /* build the VGMSTREAM */ VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag); vgmStream.vgmLoopFlag = loop_flag; vgmStream.vgmChannelCount = channel_count; vgmStream.vgmSampleRate = sample_rate; vgmStream.vgmTotalSamples = (int)(fileReader.Read_32bits(offset + 0x04) * 28 / 16); vgmStream.vgmLayout = new Interleave(); vgmStream.vgmInterleaveBlockSize = (int)(fileReader.Read_32bits(offset + 0x0C) / 2); vgmStream.vgmDecoder = new PSX_Decoder(); if (loop_flag) { vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bits(offset + 0x7FC) * 28 / 16; vgmStream.vgmLoopEndSample = vgmStream.vgmTotalSamples; } UInt64 start_offset = offset + fileReader.Read_32bits(offset + 08); if (InitReader) { for (int i = 0; i < channel_count; i++) { vgmStream.vgmChannel[i].fReader = (StreamReader.IReader)Activator.CreateInstance(fileReader.GetType());; vgmStream.vgmChannel[i].fReader.Open(fileReader.GetFilename()); vgmStream.vgmChannel[i].fReader.SetSessionID(fileReader.GetSessionID()); vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = start_offset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i); } } }
public UInt64 IsFormat(StreamReader.IReader fileReader, UInt64 offset, UInt64 length) { // Check for Mark ID ("RAKI") if (fileReader.Read_32bitsBE(offset) != 0x52414B49) { return(0); } // Check for Mark ID ("Cafeadpc") if ((fileReader.Read_32bitsBE(offset + 8) != 0x43616665) && (fileReader.Read_32bitsBE(offset + 10) != 0x61647063)) { return(0); } uint file_length = fileReader.Read_32bitsBE(offset + 0x4C) + fileReader.Read_32bitsBE(offset + 0x14); if (fileReader.Read_32bitsBE(offset + 0x44) == 0x6461744C) { file_length = (fileReader.Read_32bitsBE(offset + 0x58) * 2) + 0x1C + 0x1C + fileReader.Read_32bitsBE(offset + 0x14); } ; return(file_length); }