private void InitializeLossless ()
{
if (0 != m_info.BlockingDegree)
{
m_nBlockSize = 1 << m_info.BlockingDegree;
m_nBlockArea = 1 << (m_info.BlockingDegree * 2);
m_nBlockSamples = m_nBlockArea * m_nChannelCount;
m_nWidthBlocks = ((int)m_info.Width + m_nBlockSize - 1) >> m_info.BlockingDegree;
m_nHeightBlocks = ((int)m_info.Height + m_nBlockSize - 1) >> m_info.BlockingDegree;
m_ptrOperations = new byte[m_nWidthBlocks * m_nHeightBlocks];
m_ptrColumnBuf = new sbyte[m_nBlockSize * m_nChannelCount];
m_ptrLineBuf = new sbyte[m_nChannelCount * (m_nWidthBlocks << m_info.BlockingDegree)];
m_ptrDecodeBuf = new sbyte[m_nBlockSamples];
m_ptrArrangeBuf = new sbyte[m_nBlockSamples];
InitializeArrangeTable();
}
if (0x00020200 == m_info.Version)
{
if (EriCode.RunlengthHuffman == m_info.Architecture)
{
m_pHuffmanTree = new HuffmanTree();
}
else if (EriCode.Nemesis == m_info.Architecture)
{
m_pProbERISA = new ErisaProbModel();
}
}
if (EriCode.RunlengthHuffman == m_info.Architecture)
m_context = new HuffmanDecodeContext (0x10000);
else if (EriCode.Nemesis == m_info.Architecture)
m_context = new ProbDecodeContext (0x10000);
else
m_context = new RLEDecodeContext (0x10000);
}
private void InitializeLossy ()
{
if (3 != m_info.BlockingDegree)
throw new InvalidFormatException();
m_nBlockSize = 1 << m_info.BlockingDegree;
m_nBlockArea = 1 << (m_info.BlockingDegree * 2);
m_nBlockSamples = m_nBlockArea * m_nChannelCount;
m_nWidthBlocks = ((int)m_info.Width + m_nBlockSize * 2 - 1) >> (m_info.BlockingDegree + 1);
m_nHeightBlocks = ((int)m_info.Height + m_nBlockSize * 2 - 1) >> (m_info.BlockingDegree + 1);
if (CvType.LOT_ERI == m_info.Transformation)
{
++m_nWidthBlocks;
++m_nHeightBlocks;
}
if (EriSampling.YUV_4_4_4 == m_info.SamplingFlags)
{
m_nBlocksetCount = m_nChannelCount * 4;
}
else if (EriSampling.YUV_4_1_1 == m_info.SamplingFlags)
{
switch (m_nChannelCount)
{
case 1:
m_nBlocksetCount = 4;
break;
case 3:
m_nBlocksetCount = 6;
break;
case 4:
m_nBlocksetCount = 10;
break;
default:
throw new InvalidFormatException();
}
}
else
throw new InvalidFormatException();
m_ptrDecodeBuf = new sbyte[m_nBlockArea * 16];
m_ptrVertBufLOT = new float[m_nBlockSamples * 2 * m_nWidthBlocks];
m_ptrHorzBufLOT = new float[m_nBlockSamples * 2];
m_ptrBlocksetBuf = new float[16][];
m_ptrMatrixBuf = new float[m_nBlockArea * 16];
m_ptrIQParamBuf = new float[m_nBlockArea * 2];
m_ptrIQParamTable = new byte[m_nBlockArea * 2];
int dwTotalBlocks = m_nWidthBlocks * m_nHeightBlocks;
m_ptrLossyOps = new sbyte[dwTotalBlocks * 2];
m_ptrImageBuf = new sbyte[dwTotalBlocks * m_nBlockArea * m_nBlocksetCount];
m_ptrMovingVector = new sbyte[dwTotalBlocks * 4];
m_ptrMoveVecFlags = new sbyte[dwTotalBlocks];
m_ptrMovePrevBlocks = new int[dwTotalBlocks * 4];
for (int i = 0; i < 16; i ++)
{
m_ptrBlocksetBuf[i] = new float[m_nBlockArea];
}
m_nYUVPixelBytes = m_nChannelCount;
if (3 == m_nYUVPixelBytes)
{
m_nYUVPixelBytes = 4;
}
m_nYUVLineBytes = ((m_nYUVPixelBytes * m_nWidthBlocks * m_nBlockSize * 2) + 0xF) & (~0xF);
int nYUVImageSize = m_nYUVLineBytes * m_nHeightBlocks * m_nBlockSize * 2;
m_ptrBlockLineBuf = new sbyte[m_nYUVLineBytes * 16];
m_ptrYUVImage = new sbyte[nYUVImageSize];
InitializeZigZagTable();
m_pHuffmanTree = new HuffmanTree();
m_pProbERISA = new ErisaProbModel();
m_context = new HuffmanDecodeContext (0x10000);
}
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;
}
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;
}
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;
}
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;
}