public int WAVReader(string file, bool ExtendedFlagging = false)
{
Success = false;
string[] Files;
bool HasLoop = false;
bool[] Loop;
{
if (!file.EndsWith(".0"))
{
return(WAVReaderStraight(file));
}
file = file.Remove(file.Length - 2);
i2 = 0;
System.Collections.Generic.List <string> files =
new System.Collections.Generic.List <string>();
System.Collections.Generic.List <bool> loop =
new System.Collections.Generic.List <bool>();
while (true)
{
if (File.Exists(file + "." + i2 + ".wav"))
{
files.Add(file + "." + i2 + ".wav"); loop.Add(false);
}
else if (File.Exists(file + "." + i2 + ".loop.wav"))
{
files.Add(file + "." + i2 + ".loop.wav"); loop.Add(true); HasLoop = true;
}
else
{
break;
}
i2++;
}
Files = files.ToArray();
Loop = loop.ToArray();
}
int[] Sizes = new int[Files.Length];
ushort Channels = 0;
int AlignVAG, Size = 0, SampleRate = 0;
VAGData = new VAGFile();
Stream reader;
WAV.Header Header;
for (i = 0; i < Files.Length; i++)
{
reader = File.OpenReader(Files[i]);
Header = reader.ReadWAVHeader();
if (!Header.IsSupported)
{
reader.C(); return(2);
}
if (i == 0)
{
SampleRate = Header.SampleRate;
ch = Channels = Header.Channels; VBS = BS * ch;
}
if (Header.Channels != Channels)
{
reader.C(); return(3);
}
if (Header.SampleRate != SampleRate)
{
reader.C(); return(4);
}
Sizes[i] = Header.Size / Header.Bytes;
Size += Sizes[i].A(VBS);
reader.C();
}
VAGData.Size = Size / VBS;
VAGData.Data = new int[Size];
VAGData.Flags = new byte[VAGData.Size];
if (HasLoop)
{
for (i = 0; i < VAGData.Size; i++)
{
VAGData.Flags[i] = 0x2;
}
}
i2 = 0;
int Start = 0, End = 0;
fixed(int *dataPtr = VAGData.Data)
{
int *localDataPtr = dataPtr;
for (i = 0; i < Files.Length; i++)
{
reader = File.OpenReader(Files[i]);
Header = reader.ReadWAVHeader();
if (Header.Bytes == 1 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < Sizes[i]; i1++, localDataPtr++)
{
*localDataPtr = (reader.RU8() - 0x80) << 16;
}
}
else if (Header.Bytes == 2 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < Sizes[i]; i1++, localDataPtr++)
{
*localDataPtr = reader.RI16() << 8;
}
}
else if (Header.Bytes == 3 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < Sizes[i]; i1++, localDataPtr++)
{
*localDataPtr = reader.RU8() | (reader.RI16() << 8);
}
}
else if (Header.Bytes == 4 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < Sizes[i]; i1++, localDataPtr++)
{
*localDataPtr = reader.RI32() >> 8;
}
}
else if (Header.Bytes == 4 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < Sizes[i]; i1++, localDataPtr++)
{
*localDataPtr = (int)(reader.RF32() * 8388608.0);
}
}
else if (Header.Bytes == 8 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < Sizes[i]; i1++, localDataPtr++)
{
*localDataPtr = (int)(reader.RF64() * 8388608.0);
}
}
reader.C();
AlignVAG = Sizes[i].A(VBS) - Sizes[i];
localDataPtr += AlignVAG;
AlignVAG = (Sizes[i] + AlignVAG) / VBS;
End += AlignVAG;
End--;
if (Loop[i])
{
VAGData.Flags[Start] = 0x6; VAGData.Flags[End] = 0x3;
}
else if (ExtendedFlagging)
{
VAGData.Flags[Start] = 0x4;
}
if (i + 1 == Files.Length && !Loop[i])
{
VAGData.Flags[End] = 0x1;
}
Start += AlignVAG;
End++;
}
}
VAGData.Channels = ch;
VAGData.SampleRate = SampleRate;
Success = true;
return(0);
}
public void VAGReader(string file)
{
Success = false;
if (!File.Exists(file + ".vag"))
{
return;
}
VAGData = new VAGFile();
Stream reader = File.OpenReader(file + ".vag", true);
if (reader.RU32() != 0x70474156)
{
return;
}
VAGData.Version = reader.RU32E(true);
reader.RU32();
VAGData.Size = reader.RI32E(true);
VAGData.SampleRate = reader.RI32E(true);
reader.RU32();
reader.RU32();
reader.RU16();
VAGData.Channels = reader.RU16();
if (VAGData.Channels < 2)
{
VAGData.Channels = 1;
}
byte[] name = reader.RBy(0x10);
for (i = 0; i < 0x10; i++)
{
VAGData.Name[i] = name[i];
}
name = null;
bool HEVAG = VAGData.Version == 0x00020001 || VAGData.Version == 0x00030000;
if (!HEVAG)
{
VAGData.Channels = 1;
}
ch = VAGData.Channels;
VBS = BS * ch;
int[] samp = new int[ch * 4];
if (VAGData.Size + 0x30 > reader.LI64)
{
VAGData.Size = reader.L - 0x30;
}
VAGData.Size = (VAGData.Size / VAGData.Channels) >> 4;
VAGData.Flags = new byte [VAGData.Size];
VAGData.Data = new int[VAGData.Size * VBS];
fixed(int *sampPtr = samp)
fixed(int *shF = ShiftFactor)
fixed(int *HEVAG1 = VAG.HEVAG1)
fixed(int *HEVAG2 = VAG.HEVAG2)
fixed(int *HEVAG3 = VAG.HEVAG3)
fixed(int *HEVAG4 = VAG.HEVAG4)
fixed(int *dataPtr = VAGData.Data)
{
int *v1 = sampPtr;
int *v2 = sampPtr + ch;
int *v3 = sampPtr + ch * 2;
int *v4 = sampPtr + ch * 3;
int *localDataPtr = dataPtr;
for (i1 = 0; i1 < VAGData.Size; i1++, localDataPtr += VBS)
{
for (c = 0; c < ch; c++)
{
s = reader.RU8();
PrNR = (s & 0xF0) >> 4;
ShF = s & 0x0F;
s = reader.RU8();
PrNR = (s & 0xF0) | PrNR;
VAGData.Flags[i1] = (byte)(s & 0xF);
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
s = reader.RU8();
fourBit[i] = s & 0x0F;
fourBit[i2] = (s & 0xF0) >> 4;
}
HEVAG_1 = HEVAG1[PrNR]; HEVAG_2 = HEVAG2[PrNR];
HEVAG_3 = HEVAG3[PrNR]; HEVAG_4 = HEVAG4[PrNR];
s1 = v1[c]; s2 = v2[c]; s3 = v3[c]; s4 = v4[c];
ShFf = 20 - ShF;
for (i = 0; i < BS; i++)
{
d0 = shF[fourBit[i]] << ShFf;
g = ((s1 * HEVAG_1 + s2 * HEVAG_2 + s3 * HEVAG_3 + s4 * HEVAG_4) >> 5) + d0;
s4 = s3; s3 = s2; s2 = s1; s1 = g >> 8;
localDataPtr[i * ch + c] = g;
}
v1[c] = s1; v2[c] = s2; v3[c] = s3; v4[c] = s4;
}
}
}
reader.C();
Success = true;
}
public int WAVReaderStraight(string file, bool ExtendedFlagging = false)
{
Success = false;
VAGData = new VAGFile();
Stream reader = File.OpenReader(file + ".wav");
WAV.Header Header = reader.ReadWAVHeader();
if (!Header.IsSupported)
{
reader.C(); return(1);
}
ch = Header.Channels;
VBS = BS * ch;
VAGData.Size = Header.Size / Header.Bytes;
VAGData.Data = new int[VAGData.Size.A(VBS)];
fixed(int *dataPtr = VAGData.Data)
{
int *localDataPtr = dataPtr;
if (Header.Bytes == 1 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, localDataPtr++)
{
*localDataPtr = (reader.RU8() - 0x80) << 16;
}
}
else if (Header.Bytes == 2 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, localDataPtr++)
{
*localDataPtr = reader.RI16() << 8;
}
}
else if (Header.Bytes == 3 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, localDataPtr++)
{
*localDataPtr = reader.RU8() | (reader.RI16() << 8);
}
}
else if (Header.Bytes == 4 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, localDataPtr++)
{
*localDataPtr = reader.RI32() >> 8;
}
}
else if (Header.Bytes == 4 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, localDataPtr++)
{
*localDataPtr = (int)(reader.RF32() * 8388608.0);
}
}
else if (Header.Bytes == 8 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, localDataPtr++)
{
*localDataPtr = (int)(reader.RF64() * 8388608.0);
}
}
}
VAGData.Size = VAGData.Size.A(VBS, VBS);
VAGData.Channels = ch;
VAGData.SampleRate = Header.SampleRate;
VAGData.Flags = new byte[VAGData.Size];
if (ExtendedFlagging)
{
VAGData.Flags[0] = 0x4;
}
VAGData.Flags[VAGData.Size - 1] = 0x1;
reader.C();
Success = true;
return(0);
}
public void VAGReader(string file)
{
Success = false;
if (!File.Exists(file + ".vag"))
{
return;
}
VAGData = new VAGFile();
Stream reader = File.OpenReader(file + ".vag", true);
if (reader.RU32() != 0x70474156)
{
return;
}
VAGData.Version = reader.RU32E(true);
reader.RU32();
VAGData.Size = reader.RU32E(true);
VAGData.SampleRate = reader.RU32E(true);
reader.RU32();
reader.RU32();
reader.RU16();
VAGData.Channels = reader.RU16();
if (VAGData.Channels < 2)
{
VAGData.Channels = 1;
}
VAGData.Name = reader.RS(0x10);
bool HEVAG = VAGData.Version == 0x00020001 || VAGData.Version == 0x00030000;
if (!HEVAG)
{
VAGData.Channels = 1;
}
ch = VAGData.Channels;
VBS = BS * ch;
four_bit = new int[BS]; four_bitPtr = four_bit.GetPtr();
temp_buffer = new int[BS]; temp_bufferPtr = temp_buffer.GetPtr();
S1 = new int[VAGData.Channels]; S1Ptr = S1.GetPtr();
S2 = new int[VAGData.Channels]; S2Ptr = S2.GetPtr();
S3 = new int[VAGData.Channels]; S3Ptr = S3.GetPtr();
S4 = new int[VAGData.Channels]; S4Ptr = S4.GetPtr();
if (VAGData.Size + 0x30 > reader.I64L)
{
VAGData.Size = reader.U32L - 0x30;
}
VAGData.Size = (VAGData.Size / VAGData.Channels) >> 4;
VAGData.Flags = new byte [VAGData.Size];
VAGData.Data = new int[VAGData.Size * VBS];
VAGData.DataPtr = VAGData.Data.GetPtr();
VAGData.OriginDataPtr = VAGData.DataPtr;
if (HEVAG)
{
for (i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
{
for (c = 0; c < ch; c++)
{
s = reader.RU8();
PrNR = (s & 0xF0) >> 4;
ShF = s & 0x0F;
s = reader.RU8();
PrNR = (s & 0xF0) | PrNR;
VAGData.Flags[i1] = (byte)(s & 0xF);
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
s = reader.RU8();
four_bitPtr[i] = s & 0x0F;
four_bitPtr[i2] = s & 0xF0;
four_bitPtr[i2] >>= 4;
}
HEVAG_1 = HEVAG1Ptr[PrNR]; HEVAG_2 = HEVAG2Ptr[PrNR];
HEVAG_3 = HEVAG3Ptr[PrNR]; HEVAG_4 = HEVAG4Ptr[PrNR];
tS1 = S1Ptr[c]; tS2 = S2Ptr[c]; tS3 = S3Ptr[c]; tS4 = S4Ptr[c];
ShFf = 20 - ShF;
for (i = 0; i < BS; i++)
{
d0 = four_bitPtr[i];
d0 = (d0 > 7 ? d0 - 16 : d0) << ShFf;
g = ((tS1 * HEVAG_1 + tS2 * HEVAG_2 +
tS3 * HEVAG_3 + tS4 * HEVAG_4) >> 5) + d0;
tS4 = tS3; tS3 = tS2; tS2 = tS1; tS1 = g >> 8;
VAGData.DataPtr[i * ch + c] = g;
}
S1Ptr[c] = tS1; S2Ptr[c] = tS2; S3Ptr[c] = tS3; S4Ptr[c] = tS4;
}
}
}
else
{
for (i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
{
s = reader.RU8();
PrNR = (s & 0xF0) >> 4;
ShF = s & 0x0F;
s = reader.RU8();
VAGData.Flags[i1] = (byte)(s & 0xF);
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
s = reader.RU8();
four_bitPtr[i] = s & 0x0F;
four_bitPtr[i2] = s & 0xF0;
four_bitPtr[i2] >>= 4;
}
HEVAG_1 = HEVAG1Ptr[PrNR]; HEVAG_2 = HEVAG2Ptr[PrNR];
tS1 = S1Ptr[c]; tS2 = S2Ptr[c];
ShFf = 20 - ShF;
i = 0;
for (i = 0; i < BS; i++)
{
d0 = four_bitPtr[i];
d0 = (d0 > 7 ? d0 - 16 : d0) << ShFf;
g = ((tS1 * HEVAG_1 + tS2 * HEVAG_2) >> 5) + d0;
tS2 = tS1; tS1 = g >> 8;
VAGData.DataPtr[i * ch + c] = g;
}
S1Ptr[c] = tS1; S2Ptr[c] = tS2;
}
}
reader.C();
Success = true;
}
public void Dispose()
{
VAGData = default;
}
public VAG()
{
VAGData = new VAGFile();
HEVAG1Ptr = HEVAG1.GetPtr(); HEVAG2Ptr = HEVAG2.GetPtr();
HEVAG3Ptr = HEVAG3.GetPtr(); HEVAG4Ptr = HEVAG4.GetPtr();
}
public VAG()
{
VAGData = new VAGFile();
}
public void VAGReader(string file)
{
Success = false;
if (!File.Exists(file + ".vag"))
{
return;
}
VAGData = new VAGFile();
Stream reader = File.OpenReader(file + ".vag", true);
if (reader.ReadUInt32() != 0x70474156)
{
return;
}
VAGData.Version = reader.ReadUInt32Endian(true);
reader.ReadUInt32();
VAGData.Size = reader.ReadUInt32Endian(true);
VAGData.SampleRate = reader.ReadUInt32Endian(true);
reader.ReadUInt32();
reader.ReadUInt32();
reader.ReadUInt16();
VAGData.Channels = reader.ReadUInt16();
if (VAGData.Channels < 2)
{
VAGData.Channels = 1;
}
VAGData.Name = reader.ReadString(0x10);
bool HEVAG = VAGData.Version == 0x00020001 || VAGData.Version == 0x00030000;
if (!HEVAG)
{
VAGData.Channels = 1;
}
ch = VAGData.Channels;
VBS = BS * ch;
four_bit = new int[BS]; four_bitPtr = four_bit.GetPtr();
temp_buffer = new int[BS]; temp_bufferPtr = temp_buffer.GetPtr();
Samp1 = new int[VAGData.Channels]; S1Ptr = Samp1.GetPtr();
Samp2 = new int[VAGData.Channels]; S2Ptr = Samp2.GetPtr();
Samp3 = new int[VAGData.Channels]; S3Ptr = Samp3.GetPtr();
Samp4 = new int[VAGData.Channels]; S4Ptr = Samp4.GetPtr();
if (VAGData.Size + 0x30 > reader.LongLength)
{
VAGData.Size = reader.UIntLength - 0x30;
}
VAGData.Size = (VAGData.Size / VAGData.Channels) >> 4;
VAGData.Flags = new byte [VAGData.Size];
VAGData.Data = new int[VAGData.Size * VBS];
VAGData.DataPtr = VAGData.Data.GetPtr();
VAGData.OriginDataPtr = VAGData.DataPtr;
if (HEVAG)
{
for (i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
{
for (c = 0; c < ch; c++)
{
s = reader.ReadByte();
PrNR = (s & 0xF0) >> 4;
ShF = s & 0x0F;
s = reader.ReadByte();
PrNR = (s & 0xF0) | PrNR;
VAGData.Flags[i1] = (byte)(s & 0xF);
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
s = reader.ReadByte();
four_bitPtr[i] = s & 0x0F;
four_bitPtr[i2] = s & 0xF0;
four_bitPtr[i2] >>= 4;
}
HEVAG_1 = HEVAG1Ptr[PrNR]; HEVAG_2 = HEVAG2Ptr[PrNR];
HEVAG_3 = HEVAG3Ptr[PrNR]; HEVAG_4 = HEVAG4Ptr[PrNR];
tS1 = S1Ptr[c]; tS2 = S2Ptr[c]; tS3 = S3Ptr[c]; tS4 = S4Ptr[c];
DecodeHEVAG();
S1Ptr[c] = tS1; S2Ptr[c] = tS2; S3Ptr[c] = tS3; S4Ptr[c] = tS4;
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
VAGData.DataPtr[i * ch + c] = temp_bufferPtr[i];
VAGData.DataPtr[i2 * ch + c] = temp_bufferPtr[i2];
}
}
}
}
else
{
for (i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr += VBS)
{
s = reader.ReadByte();
PrNR = (s & 0xF0) >> 4;
ShF = s & 0x0F;
s = reader.ReadByte();
VAGData.Flags[i1] = (byte)(s & 0xF);
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
s = reader.ReadByte();
four_bitPtr[i] = s & 0x0F;
four_bitPtr[i2] = s & 0xF0;
four_bitPtr[i2] >>= 4;
}
VAG_1 = HEVAG1Ptr[PrNR]; VAG_2 = HEVAG2Ptr[PrNR];
tS1 = S1Ptr[c]; tS2 = S2Ptr[c];
i = 0; i2 = 1;
while (i < BS)
{
d0 = four_bitPtr[i];
d1 = four_bitPtr[i2];
if (d0 > 7)
{
d0 -= 16;
}
if (d1 > 7)
{
d1 -= 16;
}
d0 = d0 << (20 - ShF);
d1 = d1 << (20 - ShF);
g = ((tS1 >> 8) * VAG_1 + (tS2 >> 8) * VAG_2) >> 5;
tS2 = tS1; tS1 = g + d0;
g = ((tS1 >> 8) * VAG_1 + (tS2 >> 8) * VAG_2) >> 5;
tS2 = tS1; tS1 = g + d1;
temp_bufferPtr[i] = tS2;
temp_bufferPtr[i2] = tS1;
i += 2;
i2 += 2;
}
S1Ptr[c] = tS1; S2Ptr[c] = tS2;
for (i = 0, i2 = 1; i < BS; i += 2, i2 += 2)
{
VAGData.DataPtr[i] = temp_bufferPtr[i];
VAGData.DataPtr[i2] = temp_bufferPtr[i2];
}
}
}
VAGData.DataPtr = VAGData.OriginDataPtr;
reader.Close();
Success = true;
}
public int WAVReaderStraight(bool ExtendedFlagging = false)
{
VAGData = new VAGFile();
Stream reader = File.OpenReader(file + ".wav");
WAV.Header Header = reader.ReadWAVHeader();
if (!Header.IsSupported)
{
reader.Close(); return(1);
}
ch = Header.Channels;
VBS = BS * ch;
VAGData.Size = Header.Size / Header.Bytes;
VAGData.Data = new int[VAGData.Size.Align(VBS)];
VAGData.DataPtr = VAGData.Data.GetPtr();
VAGData.OriginDataPtr = VAGData.DataPtr;
if (Header.Bytes == 1 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = (reader.ReadByte() - 0x80) << 16;
}
}
else if (Header.Bytes == 2 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = reader.ReadInt16() << 8;
}
}
else if (Header.Bytes == 3 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = reader.ReadByte() | (reader.ReadInt16() << 8);
}
}
else if (Header.Bytes == 4 && Header.Format == 0x01)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = reader.ReadInt32() >> 8;
}
}
else if (Header.Bytes == 4 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = (int)(reader.ReadSingle() * 8388608.0);
}
}
else if (Header.Bytes == 8 && Header.Format == 0x03)
{
for (int i1 = 0; i1 < VAGData.Size; i1++, VAGData.DataPtr++)
{
*VAGData.DataPtr = (int)(reader.ReadDouble() * 8388608.0);
}
}
VAGData.Size = VAGData.Size.Align(VBS, VBS);
VAGData.DataPtr = VAGData.OriginDataPtr;
VAGData.Channels = ch;
VAGData.SampleRate = Header.SampleRate;
VAGData.Flags = new byte[VAGData.Size];
if (ExtendedFlagging)
{
VAGData.Flags[0] = 0x4;
}
VAGData.Flags[VAGData.Size - 1] = 0x1;
reader.Close();
return(0);
}
public VAG(string filepath)
{
VAGData = new VAGFile(); file = filepath;
}
