public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
{
UInt64 start_offset;
UInt64 i;
int thpVersion = fileReader.Read_8Bits(offset + 0x06);
/* fill in the vital statistics */
start_offset = fileReader.Read_32bitsBE(offset + 0x28);
// Get info from the first block
UInt64 componentTypeOffset = offset + fileReader.Read_32bitsBE(offset + 0x20);
uint numComponents = fileReader.Read_32bitsBE(componentTypeOffset);
UInt64 componentDataOffset = componentTypeOffset + 0x14;
componentTypeOffset += 4;
for (i = 0; i < numComponents; i++)
{
if (fileReader.Read_8Bits(componentTypeOffset + i) == 1) // audio block
{
uint channel_count = fileReader.Read_32bitsBE(componentDataOffset);
/* build the VGMSTREAM */
VGM_Utils.allocate_vgmStream(ref vgmStream, (int)channel_count, false);
vgmStream.vgmChannelCount = (int)channel_count;
vgmStream.vgmSampleRate = (int)fileReader.Read_32bitsBE(componentDataOffset + 4);
vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(componentDataOffset + 8);
break;
}
else
{
if (thpVersion == 0x10)
{
componentDataOffset += 0x0c;
}
else
{
componentDataOffset += 0x08;
}
}
}
vgmStream.vgmTHPNextFrameSize = fileReader.Read_32bitsBE(offset + 0x18);
vgmStream.vgmDecoder = new DSP_Decoder();
vgmStream.vgmLayout = new Blocked();
vgmStream.vgmLayoutType = VGM_Layout_Type.THP_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.THP_Block_Update(offset + start_offset, ref vgmStream);
}
}
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 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 void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
{
bool loop_flag = (fileReader.Read_32bits(offset + 0x14) != 0xFFFFFFFF);
int channel_count = (int)fileReader.Read_32bits(offset + 0x0C);
int sample_rate = (int)fileReader.Read_32bits(offset + 0x18);
m_Filename = fileReader.Read_String(offset + 0x34, 0x20);
/* 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 + 0x08) * 28 / 16);
if (channel_count == 1)
{
vgmStream.vgmLayout = new NoLayout();
}
else
{
vgmStream.vgmLayout = new Interleave();
}
vgmStream.vgmInterleaveBlockSize = (int)(fileReader.Read_32bits(offset + 0x04) / 2);
vgmStream.vgmDecoder = new PSX_Decoder();
if (loop_flag)
{
vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bits(offset + 0x14);
vgmStream.vgmLoopEndSample = (int)(fileReader.Read_32bits(offset + 0x08) * 28 / 16);
}
UInt64 start_offset = offset + 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].fReader.SetSessionID(fileReader.GetSessionID());
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)
{
UInt64 startOffset = 0;
UInt64[] start_offset = new UInt64[2] {
0x140, 0x148
};
if (fileReader.Read_32bitsBE(offset + 0x44) == 0x6461744C) // datL
{
startOffset = 0x5e;
start_offset[0] = fileReader.Read_32bitsBE(offset + 0x48);
start_offset[1] = fileReader.Read_32bitsBE(offset + 0x54);
}
else
{
startOffset = 0x52;
}
int channel_count = fileReader.Read_16bitsBE(offset + startOffset);
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_32bitsBE(offset + startOffset + 0x14) / 8 * 14) / channel_count;
vgmStream.vgmSampleRate = fileReader.Read_16bitsBE(offset + startOffset + 0x4);
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] = (Int16)fileReader.Read_16bitsBE(offset + startOffset + (UInt64)(0x2C + (i * 2) + (j * 0x60)));
}
}
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].startOffset = vgmStream.vgmChannel[i].currentOffset = offset + start_offset[i];
}
}
}
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
{
bool loop_flag = false;
UInt32 loop_start_sample = 0;
UInt32 loop_start_offset;
UInt32 loop_end_sample = 0;
UInt32 loop_end_offset;
Int16 coef1 = 0;
Int16 coef2 = 0;
int i;
int channel_count = fileReader.Read_8Bits(offset + 0x07);
/* check version signature, read loop info */
UInt16 version_signature = fileReader.Read_16bitsBE(offset + 0x12);
UInt64 criOffset = (UInt64)fileReader.Read_16bitsBE(offset + 2) + 4;
/* encryption */
if (version_signature == 0x0408)
{
//if (find_key(streamFile, &xor_start, &xor_mult, &xor_add))
//{
// coding_type = coding_CRI_ADX_enc;
// version_signature = 0x0400;
//}
}
if (version_signature == 0x0300)
{ /* type 03 */
if (criOffset - 6 >= 0x2c)
{ /* enough space for loop info? */
loop_flag = (fileReader.Read_32bitsBE(offset + 0x18) != 0);
loop_start_sample = (fileReader.Read_32bitsBE(offset + 0x1c));
loop_start_offset = fileReader.Read_32bitsBE(offset + 0x20);
loop_end_sample = fileReader.Read_32bitsBE(offset + 0x24);
loop_end_offset = fileReader.Read_32bitsBE(offset + 0x28);
}
}
else if (version_signature == 0x0400)
{
UInt32 ainf_info_length = 0;
if (fileReader.Read_32bitsBE(offset + 0x24) == 0x41494E46) /* AINF Header */
{
ainf_info_length = fileReader.Read_32bitsBE(offset + 0x28);
}
if (criOffset - ainf_info_length - 6 >= 0x38)
{ /* enough space for loop info? */
loop_flag = (fileReader.Read_32bitsBE(offset + 0x24) != 0);
loop_start_sample = (fileReader.Read_32bitsBE(offset + 0x28));
loop_start_offset = fileReader.Read_32bitsBE(offset + 0x2C);
loop_end_sample = fileReader.Read_32bitsBE(offset + 0x30);
loop_end_offset = fileReader.Read_32bitsBE(offset + 0x34);
}
}
else if (version_signature == 0x0500)
{ /* found in some SFD : Buggy Heat, appears to have no loop */
}
/* build the VGMSTREAM */
VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);
vgmStream.vgmChannelCount = channel_count;
vgmStream.vgmSampleRate = (int)fileReader.Read_32bitsBE(offset + 0x08);
vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE(offset + 0x0C);
vgmStream.vgmDecoder = new ADX_Decoder();
if (channel_count == 1)
{
vgmStream.vgmLayout = new NoLayout();
}
else
{
vgmStream.vgmLayout = new Interleave();
}
vgmStream.vgmLoopFlag = loop_flag;
if (loop_flag)
{
vgmStream.vgmLoopStartSample = (int)loop_start_sample;
vgmStream.vgmLoopEndSample = (int)loop_end_sample;
}
/* high-pass cutoff frequency, always 500 that I've seen */
UInt16 cutoff = fileReader.Read_16bitsBE(offset + 0x10);
/* calculate filter coefficients */
{
double x, y, z, a, b, c;
x = cutoff;
y = vgmStream.vgmSampleRate;
z = Math.Cos(2.0 * Math.PI * x / y);
a = Math.Sqrt(2) - z;
b = Math.Sqrt(2) - 1.0;
c = (a - Math.Sqrt((a + b) * (a - b))) / b;
coef1 = (Int16)Math.Floor(c * 8192);
coef2 = (Int16)Math.Floor(c * c * -4096);
}
vgmStream.vgmInterleaveBlockSize = 18;
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].adpcm_coef[0] = coef1;
vgmStream.vgmChannel[i].adpcm_coef[1] = coef2;
vgmStream.vgmChannel[i].startOffset = vgmStream.vgmChannel[i].currentOffset = offset + criOffset + (UInt64)(vgmStream.vgmInterleaveBlockSize * i);
}
}
}
public void Init(StreamReader.IReader fileReader, UInt64 offset, ref VGM_Stream vgmStream, bool InitReader, UInt64 fileLength)
{
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;
bool loop_flag = (fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0x19 : rl_head_offset + 0x21) != 0);
bool isDSP = false;
int codec_number = fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0x8 : rl_head_offset + 0x20);
int channel_count = fileReader.Read_8Bits((head_offset == 0x10) ? rl_head_offset + 0xa : rl_head_offset + 0x22);
/* build the VGMSTREAM */
VGM_Utils.allocate_vgmStream(ref vgmStream, channel_count, loop_flag);
switch (codec_number)
{
case 0:
vgmStream.vgmDecoder = new PCM8_Decoder();
break;
case 1:
vgmStream.vgmDecoder = new PCM16_Decoder();
vgmStream.vgmDecoderType = VGM_Decoder_Type.PCM16BITSBE;
break;
case 2:
isDSP = true;
vgmStream.vgmDecoder = new DSP_Decoder();
break;
}
vgmStream.vgmChannelCount = channel_count;
vgmStream.vgmLoopFlag = loop_flag;
vgmStream.vgmTotalSamples = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x14 : rl_head_offset + 0x2c);
vgmStream.vgmSampleRate = fileReader.Read_16bitsBE((head_offset == 0x10) ? rl_head_offset + 0xC : rl_head_offset + 0x24);
if (loop_flag)
{
vgmStream.vgmLoopStartSample = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x10 : rl_head_offset + 0x28);
vgmStream.vgmLoopEndSample = vgmStream.vgmTotalSamples;
}
if (channel_count == 1)
{
vgmStream.vgmLayout = new NoLayout();
}
else
{
vgmStream.vgmLayout = new Interleave();
vgmStream.vgmLayoutType = VGM_Layout_Type.Interleave_With_Shortblock;
}
vgmStream.vgmInterleaveBlockSize = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x20 : rl_head_offset + 0x38);
vgmStream.vgmInterleaveShortBlockSize = (int)fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x30 : rl_head_offset + 0x48);
if (isDSP)
{
int i, j;
int coef_spacing = ((head_offset == 0x10) ? 0x30 : 0x38);
UInt64 coef_offset1 = fileReader.Read_32bitsBE(rl_head_offset + 0x1C);
UInt64 coef_offset2 = fileReader.Read_32bitsBE(rl_head_offset + 0x10 + coef_offset1);
UInt64 coef_offset = ((head_offset == 0x10) ? 0x38 : coef_offset2 + 0x10);
for (j = 0; j < vgmStream.vgmChannelCount; j++)
{
for (i = 0; i < 16; i++)
{
vgmStream.vgmChannel[j].adpcm_coef[i] = (Int16)fileReader.Read_16bitsBE(rl_head_offset + coef_offset + (UInt64)(j * coef_spacing + i * 2));
}
}
}
UInt64 start_offset = offset + fileReader.Read_32bitsBE((head_offset == 0x10) ? rl_head_offset + 0x18 : rl_head_offset + 0x30);
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].currentOffset = start_offset + (UInt64)(i * vgmStream.vgmInterleaveBlockSize);
}
}
}