bool DecodeSoundPCM8(ERISADecodeContext context, MioDataHeader datahdr, byte[] ptrWaveBuf, int wave_pos)
{
uint nSampleCount = datahdr.SampleCount;
if (nSampleCount > m_nBufLength)
{
m_ptrBuffer3 = new sbyte [nSampleCount * m_mioih.ChannelCount];
m_nBufLength = nSampleCount;
}
if (0 != (datahdr.Flags & MIO_LEAD_BLOCK))
{
(context as HuffmanDecodeContext).PrepareToDecodeERINACode();
}
uint nBytes = nSampleCount * (uint)m_mioih.ChannelCount;
if (context.DecodeBytes(m_ptrBuffer3, nBytes) < nBytes)
{
return(false);
}
int ptrSrcBuf = 0; // (PBYTE) m_ptrBuffer3;
int nStep = m_mioih.ChannelCount;
for (int i = 0; i < m_mioih.ChannelCount; i++)
{
int ptrDstBuf = wave_pos + i;
sbyte bytValue = 0;
for (uint j = 0; j < nSampleCount; j++)
{
bytValue += m_ptrBuffer3[ptrSrcBuf++];
ptrWaveBuf[ptrDstBuf] = (byte)bytValue;
ptrDstBuf += nStep;
}
}
return(true);
}
public bool DecodeSound(ERISADecodeContext context, MioDataHeader datahdr, byte[] ptrWaveBuf, int wave_pos)
{
context.FlushBuffer();
if (m_mioih.Transformation == CvType.Lossless_ERI)
{
if (m_mioih.BitsPerSample == 8)
{
return(DecodeSoundPCM8(context, datahdr, ptrWaveBuf, wave_pos));
}
else if (m_mioih.BitsPerSample == 16)
{
return(DecodeSoundPCM16(context, datahdr, ptrWaveBuf, wave_pos));
}
}
else if ((m_mioih.Transformation == CvType.LOT_ERI) ||
(m_mioih.Transformation == CvType.LOT_ERI_MSS))
{
if ((m_mioih.ChannelCount != 2) || (m_mioih.Transformation == CvType.LOT_ERI))
{
return(DecodeSoundDCT(context, datahdr, ptrWaveBuf, wave_pos));
}
else
{
return(DecodeSoundDCT_MSS(context, datahdr, ptrWaveBuf, wave_pos));
}
}
return(false);
}
public ERISADecodeContext(uint nBufferingSize)
{
m_nIntBufCount = 0;
m_nBufferingSize = (nBufferingSize + 0x03) & ~0x03u;
m_nBufCount = 0;
m_ptrBuffer = new byte[nBufferingSize];
m_pFile = null;
m_pContext = null;
}
public MioInput(Stream file) : base(file)
{
file.Position = 0x40;
using (var erif = new EriFile(file))
{
var section = erif.ReadSection();
if (section.Id != "Header " || section.Length <= 0 || section.Length > int.MaxValue)
{
throw new InvalidFormatException();
}
m_stream_pos = 0x50 + section.Length;
int header_size = (int)section.Length;
while (header_size > 0x10)
{
section = erif.ReadSection();
header_size -= 0x10;
if (section.Length <= 0 || section.Length > header_size)
{
break;
}
if ("SoundInf" == section.Id)
{
m_info = new MioInfoHeader();
m_info.Version = erif.ReadInt32();
m_info.Transformation = (CvType)erif.ReadInt32();
m_info.Architecture = (EriCode)erif.ReadInt32();
m_info.ChannelCount = erif.ReadInt32();
m_info.SamplesPerSec = erif.ReadUInt32();
m_info.BlocksetCount = erif.ReadUInt32();
m_info.SubbandDegree = erif.ReadInt32();
m_info.AllSampleCount = erif.ReadUInt32();
m_info.LappedDegree = erif.ReadUInt32();
m_info.BitsPerSample = erif.ReadUInt32();
break;
}
header_size -= (int)section.Length;
erif.BaseStream.Seek(section.Length, SeekOrigin.Current);
}
if (null == m_info)
{
throw new InvalidFormatException("MIO sound header not found");
}
erif.BaseStream.Position = m_stream_pos;
var stream_size = erif.FindSection("Stream ");
m_stream_pos = erif.BaseStream.Position;
m_pmiod = new MioDecoder(m_info);
if (EriCode.Nemesis != m_info.Architecture)
{
m_pmioc = new HuffmanDecodeContext(0x10000);
}
else
{
throw new NotImplementedException("MIO Nemesis encoding not implemented");
}
int pcm_bitrate = (int)(m_info.SamplesPerSec * BitsPerSample * ChannelCount);
var format = new GameRes.WaveFormat();
format.FormatTag = 1;
format.Channels = (ushort)ChannelCount;
format.SamplesPerSecond = m_info.SamplesPerSec;
format.BitsPerSample = (ushort)BitsPerSample;
format.BlockAlign = (ushort)(BitsPerSample / 8 * format.Channels);
format.AverageBytesPerSecond = (uint)pcm_bitrate / 8;
this.Format = format;
m_decoded_stream = LoadChunks(erif);
if (0 != m_total_samples)
{
m_bitrate = (int)(stream_size * 8 * m_info.SamplesPerSec / m_total_samples);
}
this.PcmSize = m_total_samples * ChannelCount * BitsPerSample / 8;
m_decoded_stream.Position = 0;
}
}
public void AttachInputContext(ERISADecodeContext context)
{
m_pFile = null;
m_pContext = context;
}
public void AttachInputFile(Stream file)
{
m_pFile = file;
m_pContext = null;
}
bool DecodeSoundDCT_MSS(ERISADecodeContext context, MioDataHeader datahdr, byte[] ptrWaveBuf, int wave_pos)
{
uint nDegreeWidth = 1u << m_mioih.SubbandDegree;
uint nSampleCount = (datahdr.SampleCount + nDegreeWidth - 1) & ~(nDegreeWidth - 1);
uint nSubbandCount = (nSampleCount >> m_mioih.SubbandDegree);
uint nChannelCount = (uint)m_mioih.ChannelCount;
uint nAllSampleCount = nSampleCount * nChannelCount;
uint nAllSubbandCount = nSubbandCount;
if (nSampleCount > m_nBufLength)
{
m_ptrBuffer2 = new int[nAllSampleCount];
m_ptrBuffer3 = new sbyte[nAllSampleCount * sizeof(short)];
m_ptrDivisionTable = new byte[nAllSubbandCount];
m_ptrRevolveCode = new byte[nAllSubbandCount * 10];
m_ptrWeightCode = new int[nAllSubbandCount * 10];
m_ptrCoefficient = new int[nAllSubbandCount * 10];
m_nBufLength = nSampleCount;
}
if (context.GetABit() != 0)
{
return(false);
}
int nLastDivision = -1;
m_ptrNextDivision = 0; // within m_ptrDivisionTable;
m_ptrNextRevCode = 0; // within m_ptrRevolveCode;
m_ptrNextWeight = 0; // within m_ptrWeightCode;
m_ptrNextCoefficient = 0; // within m_ptrCoefficient;
uint i, j, k;
for (i = 0; i < nSubbandCount; i++)
{
int nDivisionCode = (int)context.GetNBits(2);
m_ptrDivisionTable[m_ptrNextDivision++] = (byte)nDivisionCode;
bool fLeadBlock = false;
if (nDivisionCode != nLastDivision)
{
if (i != 0)
{
m_ptrRevolveCode[m_ptrNextRevCode++] = (byte)context.GetNBits(2);
m_ptrWeightCode[m_ptrNextWeight++] = (int)context.GetNBits(32);
m_ptrCoefficient[m_ptrNextCoefficient++] = (int)context.GetNBits(16);
}
fLeadBlock = true;
nLastDivision = nDivisionCode;
}
uint nDivisionCount = 1u << nDivisionCode;
for (k = 0; k < nDivisionCount; k++)
{
if (fLeadBlock)
{
m_ptrRevolveCode[m_ptrNextRevCode++] = (byte)context.GetNBits(2);
fLeadBlock = false;
}
else
{
m_ptrRevolveCode[m_ptrNextRevCode++] = (byte)context.GetNBits(4);
}
m_ptrWeightCode[m_ptrNextWeight++] = (int)context.GetNBits(32);
m_ptrCoefficient[m_ptrNextCoefficient++] = (int)context.GetNBits(16);
}
}
if (nSubbandCount > 0)
{
m_ptrRevolveCode[m_ptrNextRevCode++] = (byte)context.GetNBits(2);
m_ptrWeightCode[m_ptrNextWeight++] = (int)context.GetNBits(32);
m_ptrCoefficient[m_ptrNextCoefficient++] = (int)context.GetNBits(16);
}
if (context.GetABit() != 0)
{
return(false);
}
if (0 != (datahdr.Flags & MIO_LEAD_BLOCK))
{
if (m_mioih.Architecture != EriCode.Nemesis)
{
(context as HuffmanDecodeContext).PrepareToDecodeERINACode();
}
else
{
throw new NotImplementedException("Nemesis encoding not implemented");
// context.PrepareToDecodeERISACode( );
}
}
else if (m_mioih.Architecture == EriCode.Nemesis)
{
throw new NotImplementedException("Nemesis encoding not implemented");
// context.InitializeERISACode( );
}
if (m_mioih.Architecture != EriCode.Nemesis)
{
if (context.DecodeBytes(m_ptrBuffer3, nAllSampleCount * 2) < nAllSampleCount * 2)
{
return(false);
}
int ptrHBuf = 0; // within m_ptrBuffer3;
int ptrLBuf = (int)nAllSampleCount; // within m_ptrBuffer3
for (i = 0; i < nDegreeWidth * 2; i++)
{
int ptrQuantumized = (int)i; // within (PINT) m_ptrBuffer2
for (j = 0; j < nAllSubbandCount; j++)
{
int nLow = m_ptrBuffer3[ptrLBuf++];
int nHigh = m_ptrBuffer3[ptrHBuf++] ^ (nLow >> 8);
m_ptrBuffer2[ptrQuantumized] = (nLow & 0xFF) | (nHigh << 8);
ptrQuantumized += (int)nDegreeWidth * 2;
}
}
}
else
{
throw new NotImplementedException("Nemesis encoding not implemented");
/*
* if ( context.DecodeERISACodeWords
* ( (SWORD*) m_ptrBuffer3, nAllSampleCount ) < nAllSampleCount )
* {
* return false;
* }
* for ( i = 0; i < nAllSampleCount; i ++ )
* {
* ((PINT)m_ptrBuffer2)[i] = ((SWORD*)m_ptrBuffer3)[i];
* }
*/
}
uint nSamples;
uint nRestSamples = datahdr.SampleCount;
// int ptrDstBuf = wave_pos; // within (SWORD*) ptrWaveBuf;
nLastDivision = -1;
m_ptrNextDivision = 0; // m_ptrDivisionTable;
m_ptrNextRevCode = 0; // m_ptrRevolveCode;
m_ptrNextWeight = 0; // m_ptrWeightCode;
m_ptrNextCoefficient = 0; // m_ptrCoefficient;
m_ptrNextSource = 0; // (PINT) m_ptrBuffer2;
for (i = 0; i < nSubbandCount; i++)
{
int nDivisionCode = m_ptrDivisionTable[m_ptrNextDivision++];
uint nDivisionCount = 1u << nDivisionCode;
bool fLeadBlock = false;
if (nLastDivision != nDivisionCode)
{
if (i != 0)
{
nSamples = Math.Min(nRestSamples, (uint)m_nDegreeNum);
DecodePostBlock_MSS(ptrWaveBuf, wave_pos, nSamples);
nRestSamples -= nSamples;
wave_pos += (int)(nSamples * nChannelCount * sizeof(short));
}
InitializeWithDegree(m_mioih.SubbandDegree - nDivisionCode);
nLastDivision = nDivisionCode;
fLeadBlock = true;
}
for (k = 0; k < nDivisionCount; k++)
{
if (fLeadBlock)
{
DecodeLeadBlock_MSS();
fLeadBlock = false;
}
else
{
nSamples = nRestSamples;
if (nSamples > m_nDegreeNum)
{
nSamples = (uint)m_nDegreeNum;
}
DecodeInternalBlock_MSS(ptrWaveBuf, wave_pos, nSamples);
nRestSamples -= nSamples;
wave_pos += (int)(nSamples * nChannelCount * sizeof(short));
}
}
}
if (nSubbandCount > 0)
{
nSamples = nRestSamples;
if (nSamples > m_nDegreeNum)
{
nSamples = (uint)m_nDegreeNum;
}
DecodePostBlock_MSS(ptrWaveBuf, wave_pos, nSamples);
nRestSamples -= nSamples;
wave_pos += (int)(nSamples * nChannelCount) * sizeof(short);
}
return(true);
}
bool DecodeSoundDCT(ERISADecodeContext context, MioDataHeader datahdr, byte[] ptrWaveBuf, int wave_pos)
{
uint i, j, k;
uint nDegreeWidth = 1u << m_mioih.SubbandDegree;
uint nSampleCount = (datahdr.SampleCount + nDegreeWidth - 1) & ~(nDegreeWidth - 1);
uint nSubbandCount = (nSampleCount >> m_mioih.SubbandDegree);
uint nChannelCount = (uint)m_mioih.ChannelCount;
uint nAllSampleCount = nSampleCount * nChannelCount;
uint nAllSubbandCount = nSubbandCount * nChannelCount;
if (nSampleCount > m_nBufLength)
{
m_ptrBuffer2 = new int[nAllSampleCount];
m_ptrBuffer3 = new sbyte[nAllSampleCount * sizeof(short)];
m_ptrDivisionTable = new byte[nAllSubbandCount];
m_ptrWeightCode = new int[nAllSubbandCount * 5];
m_ptrCoefficient = new int[nAllSubbandCount * 5];
m_nBufLength = nSampleCount;
}
if (context.GetABit() != 0)
{
return(false);
}
int[] pLastDivision = new int [nChannelCount];
m_ptrNextDivision = 0; // within m_ptrDivisionTable;
m_ptrNextWeight = 0; // within m_ptrWeightCode;
m_ptrNextCoefficient = 0; // within m_ptrCoefficient;
for (i = 0; i < nChannelCount; i++)
{
pLastDivision[i] = -1;
}
for (i = 0; i < nSubbandCount; i++)
{
for (j = 0; j < nChannelCount; j++)
{
int nDivisionCode = (int)context.GetNBits(2);
m_ptrDivisionTable[m_ptrNextDivision++] = (byte)nDivisionCode;
if (nDivisionCode != pLastDivision[j])
{
if (i != 0)
{
m_ptrWeightCode[m_ptrNextWeight++] = (int)context.GetNBits(32);
m_ptrCoefficient[m_ptrNextCoefficient++] = (int)context.GetNBits(16);
}
pLastDivision[j] = nDivisionCode;
}
uint nDivisionCount = 1u << nDivisionCode;
for (k = 0; k < nDivisionCount; k++)
{
m_ptrWeightCode[m_ptrNextWeight++] = (int)context.GetNBits(32);
m_ptrCoefficient[m_ptrNextCoefficient++] = (int)context.GetNBits(16);
}
}
}
if (nSubbandCount > 0)
{
for (i = 0; i < nChannelCount; i++)
{
m_ptrWeightCode[m_ptrNextWeight++] = (int)context.GetNBits(32);
m_ptrCoefficient[m_ptrNextCoefficient++] = (int)context.GetNBits(16);
}
}
if (context.GetABit() != 0)
{
return(false);
}
if (0 != (datahdr.Flags & MIO_LEAD_BLOCK))
{
if (m_mioih.Architecture != EriCode.Nemesis)
{
(context as HuffmanDecodeContext).PrepareToDecodeERINACode();
}
else
{
throw new NotImplementedException("Nemesis encoding not implemented");
// context.PrepareToDecodeERISACode();
}
}
else if (m_mioih.Architecture == EriCode.Nemesis)
{
throw new NotImplementedException("Nemesis encoding not implemented");
// context.InitializeERISACode();
}
if (m_mioih.Architecture != EriCode.Nemesis)
{
if (context.DecodeBytes(m_ptrBuffer3, nAllSampleCount * 2) < nAllSampleCount * 2)
{
return(false);
}
int ptrHBuf = 0; // within m_ptrBuffer3;
int ptrLBuf = (int)nAllSampleCount; // within m_ptrBuffer3
for (i = 0; i < nDegreeWidth; i++)
{
int ptrQuantumized = (int)i; // within (PINT) m_ptrBuffer2
for (j = 0; j < nAllSubbandCount; j++)
{
int nLow = m_ptrBuffer3[ptrLBuf++];
int nHigh = m_ptrBuffer3[ptrHBuf++] ^ (nLow >> 8);
m_ptrBuffer2[ptrQuantumized] = (nLow & 0xFF) | (nHigh << 8);
ptrQuantumized += (int)nDegreeWidth;
}
}
}
else
{
throw new NotImplementedException("Nemesis encoding not implemented");
/*
* if (context.DecodeERISACodeWords (m_ptrBuffer3, nAllSampleCount) < nAllSampleCount)
* {
* return false;
* }
* for (i = 0; i < nAllSampleCount; i++)
* {
* ((PINT)m_ptrBuffer2)[i] = ((SWORD*)m_ptrBuffer3)[i];
* }
*/
}
uint nSamples;
uint[] pRestSamples = new uint [nChannelCount];
int[] ptrDstBuf = new int [nChannelCount]; // indices within ptrWaveBuf
m_ptrNextDivision = 0; // within m_ptrDivisionTable;
m_ptrNextWeight = 0; // within m_ptrWeightCode;
m_ptrNextCoefficient = 0; // within m_ptrCoefficient;
m_ptrNextSource = 0; // within (PINT) m_ptrBuffer2;
for (i = 0; i < nChannelCount; i++)
{
pLastDivision[i] = -1;
pRestSamples[i] = datahdr.SampleCount;
ptrDstBuf[i] = wave_pos + (int)i * sizeof(short);
}
int nCurrentDivision = -1;
for (i = 0; i < nSubbandCount; i++)
{
for (j = 0; j < nChannelCount; j++)
{
int nDivisionCode = m_ptrDivisionTable[m_ptrNextDivision++];
int nDivisionCount = 1 << nDivisionCode;
int nChannelStep = (int)(nDegreeWidth * m_mioih.LappedDegree * j);
m_ptrLastDCTBuf = nChannelStep; // within m_ptrLastDCT
bool fLeadBlock = false;
if (pLastDivision[j] != nDivisionCode)
{
if (i != 0)
{
if (nCurrentDivision != pLastDivision[j])
{
InitializeWithDegree(m_mioih.SubbandDegree - pLastDivision[j]);
nCurrentDivision = pLastDivision[j];
}
nSamples = pRestSamples[j];
if (nSamples > m_nDegreeNum)
{
nSamples = (uint)m_nDegreeNum;
}
DecodePostBlock(ptrWaveBuf, ptrDstBuf[j], nSamples);
pRestSamples[j] -= nSamples;
ptrDstBuf[j] += (int)(nSamples * nChannelCount * sizeof(short));
}
pLastDivision[j] = (int)nDivisionCode;
fLeadBlock = true;
}
if (nCurrentDivision != nDivisionCode)
{
InitializeWithDegree(m_mioih.SubbandDegree - nDivisionCode);
nCurrentDivision = nDivisionCode;
}
for (k = 0; k < nDivisionCount; k++)
{
if (fLeadBlock)
{
DecodeLeadBlock();
fLeadBlock = false;
}
else
{
nSamples = pRestSamples[j];
if (nSamples > m_nDegreeNum)
{
nSamples = (uint)m_nDegreeNum;
}
DecodeInternalBlock(ptrWaveBuf, ptrDstBuf[j], nSamples);
pRestSamples[j] -= nSamples;
ptrDstBuf[j] += (int)(nSamples * nChannelCount * sizeof(short));
}
}
}
}
if (nSubbandCount > 0)
{
for (i = 0; i < nChannelCount; i++)
{
int nChannelStep = (int)(nDegreeWidth * m_mioih.LappedDegree * i);
m_ptrLastDCTBuf = nChannelStep; // within m_ptrLastDCT
if (nCurrentDivision != pLastDivision[i])
{
InitializeWithDegree(m_mioih.SubbandDegree - pLastDivision[i]);
nCurrentDivision = pLastDivision[i];
}
nSamples = pRestSamples[i];
if (nSamples > m_nDegreeNum)
{
nSamples = (uint)m_nDegreeNum;
}
DecodePostBlock(ptrWaveBuf, ptrDstBuf[i], nSamples);
pRestSamples[i] -= nSamples;
ptrDstBuf[i] += (int)(nSamples * nChannelCount * sizeof(short));
}
}
return(true);
}
bool DecodeSoundPCM16(ERISADecodeContext context, MioDataHeader datahdr, byte[] ptrWaveBuf, int wave_pos)
{
uint nSampleCount = datahdr.SampleCount;
uint nChannelCount = (uint)m_mioih.ChannelCount;
uint nAllSampleCount = nSampleCount * nChannelCount;
uint nBytes = nAllSampleCount * sizeof(short);
if (ptrWaveBuf.Length < wave_pos + (int)nBytes)
{
return(false);
}
if (nSampleCount > m_nBufLength)
{
m_ptrBuffer3 = new sbyte[nBytes];
m_ptrBuffer4 = new byte[nBytes];
m_nBufLength = nSampleCount;
}
if (0 != (datahdr.Flags & MIO_LEAD_BLOCK))
{
(context as HuffmanDecodeContext).PrepareToDecodeERINACode();
}
if (context.DecodeBytes(m_ptrBuffer3, nBytes) < nBytes)
{
return(false);
}
int pbytSrcBuf1, pbytSrcBuf2, pbytDstBuf;
for (int i = 0; i < m_mioih.ChannelCount; i++)
{
int nOffset = i * (int)nSampleCount * sizeof(short);
pbytSrcBuf1 = nOffset; // ((PBYTE) m_ptrBuffer3) + nOffset;
pbytSrcBuf2 = pbytSrcBuf1 + (int)nSampleCount; // pbytSrcBuf1 + nSampleCount;
pbytDstBuf = nOffset; // ((PBYTE) m_ptrBuffer4) + nOffset;
for (uint j = 0; j < nSampleCount; j++)
{
sbyte bytLow = m_ptrBuffer3[pbytSrcBuf2 + j];
sbyte bytHigh = m_ptrBuffer3[pbytSrcBuf1 + j];
m_ptrBuffer4[pbytDstBuf + j * sizeof(short) + 0] = (byte)bytLow;
m_ptrBuffer4[pbytDstBuf + j * sizeof(short) + 1] = (byte)(bytHigh ^ (bytLow >> 7));
}
}
if (m_ptrBuffer4.Length < nBytes)
{
return(false);
}
unsafe
{
fixed(byte *rawBuffer4 = m_ptrBuffer4, rawWaveBuf = &ptrWaveBuf[wave_pos])
{
int nStep = m_mioih.ChannelCount;
short *ptrSrcBuf = (short *)rawBuffer4;
for (int i = 0; i < m_mioih.ChannelCount; i++)
{
short *ptrDstBuf = (short *)rawWaveBuf + i; // (SWORD*) ptrWaveBuf;
short wValue = 0;
short wDelta = 0;
for (uint j = 0; j < nSampleCount; j++)
{
wDelta += *ptrSrcBuf++;
wValue += wDelta;
*ptrDstBuf = wValue;
ptrDstBuf += nStep;
}
}
}
}
return(true);
}
