//========= Copyright Valve Corporation, All rights reserved. ============//
/***************************************************************************
*
* Copyright (C) 2001 Microsoft Corporation. All Rights Reserved.
*
* File: imaadpcm.cpp
* Content: IMA ADPCM CODEC.
* History:
* Date By Reason
* ==== == ======
* 04/29/01 dereks Created.
* 06/12/01 jharding Adapted for command-line encode
*
****************************************************************************/
#include <stdio.h>
#include <wtypes.h>
#include <assert.h>
#include "imaadpcm.h"
// 1/2 the range of the searchable step indices
// for a particular block when optimizing on a
// per-block basis. Widening or narrowing this
// range may produce better/worse encodings.
// Experimentation may be necessary. Higher values
// cause each block to be encoded better, but may
// produce popping in particularly fast attacks across
// blocks, while smaller values limit the number
// of encodings you consider
#define STEPINDEXSEARCHRANGE (24)
/****************************************************************************
*
* CImaAdpcmCodec
*
* Description:
* Object constructor.
*
* Arguments:
* (void)
*
* Returns:
* (void)
*
****************************************************************************/
//
// This array is used by NextStepIndex to determine the next step index to use.
// The step index is an index to the m_asStep[] array, below.
//
const short CImaAdpcmCodec::m_asNextStep[16] =
{
-1, -1, -1, -1, 2, 4, 6, 8,
-1, -1, -1, -1, 2, 4, 6, 8
};
//
// This array contains the array of step sizes used to encode the ADPCM
// samples. The step index in each ADPCM block is an index to this array.
//
const short CImaAdpcmCodec::m_asStep[89] =
{
7, 8, 9, 10, 11, 12, 13,
14, 16, 17, 19, 21, 23, 25,
28, 31, 34, 37, 41, 45, 50,
55, 60, 66, 73, 80, 88, 97,
107, 118, 130, 143, 157, 173, 190,
209, 230, 253, 279, 307, 337, 371,
408, 449, 494, 544, 598, 658, 724,
796, 876, 963, 1060, 1166, 1282, 1411,
1552, 1707, 1878, 2066, 2272, 2499, 2749,
3024, 3327, 3660, 4026, 4428, 4871, 5358,
5894, 6484, 7132, 7845, 8630, 9493, 10442,
11487, 12635, 13899, 15289, 16818, 18500, 20350,
22385, 24623, 27086, 29794, 32767
};
CImaAdpcmCodec::CImaAdpcmCodec
(
void
)
{
}
/****************************************************************************
*
* ~CImaAdpcmCodec
*
* Description:
* Object destructor.
*
* Arguments:
* (void)
*
* Returns:
* (void)
*
****************************************************************************/
CImaAdpcmCodec::~CImaAdpcmCodec
(
void
)
{
}
/****************************************************************************
*
* Initialize
*
* Description:
* Initializes the object.
*
* Arguments:
* LPCIMAADPCMWAVEFORMAT [in]: encoded data format.
* BOOL [in]: TRUE to initialize the object as an encoder.
*
* Returns:
* BOOL: TRUE on success.
*
****************************************************************************/
BOOL
CImaAdpcmCodec::Initialize
(
LPCIMAADPCMWAVEFORMAT pwfxEncode,
CODEC_MODE cmCodecMode
)
{
static const LPFNIMAADPCMCONVERT apfnConvert[2][2] =
{
{
DecodeM16,
DecodeS16
},
{
EncodeM16,
EncodeS16
}
};
if(!IsValidImaAdpcmFormat(pwfxEncode))
{
return FALSE;
}
//
// Save the format data
//
m_wfxEncode = *pwfxEncode;
m_cmCodecMode = cmCodecMode;
//
// Set up the conversion function
//
m_pfnConvert = apfnConvert[!(m_cmCodecMode == CODEC_MODE_DECODE)][m_wfxEncode.wfx.nChannels - 1];
//
// Initialize the stepping indices
//
m_nStepIndexL = m_nStepIndexR = 0;
return TRUE;
}
/****************************************************************************
*
* Convert
*
* Description:
* Converts data from the source to destination format.
*
* Arguments:
* LPCVOID [in]: source buffer.
* LPVOID [out]: destination buffer.
* UINT [in]: block count.
*
* Returns:
* BOOL: TRUE on success.
*
****************************************************************************/
BOOL
CImaAdpcmCodec::Convert
(
LPCVOID pvSrc,
LPVOID pvDst,
UINT cBlocks
)
{
// Array of decoders
static const LPFNIMAADPCMCONVERT apfnDecoders[2] =
{
DecodeM16,
DecodeS16
};
// Both destination and source block sizes
DWORD dwSrcBlockSize = m_wfxEncode.wfx.nChannels * m_wfxEncode.wSamplesPerBlock * sizeof(short);
DWORD dwDstBlockSize = m_wfxEncode.wfx.nBlockAlign;
// Zero out the output
ZeroMemory( pvDst, cBlocks * dwDstBlockSize );
switch( m_cmCodecMode )
{
case CODEC_MODE_DECODE:
// If we are decoding, just do it
return m_pfnConvert( (LPBYTE)pvSrc, (LPBYTE)pvDst, cBlocks, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR );
case CODEC_MODE_ENCODE_NORMAL:
// Normal encode
// We have some output right now, so this becomes a separate case.
// Otherwise, it would be the same as CODEC_MODE_DECODE
{
printf("Using normal encoding...\n");
// Allocate temporary buffers
LPBYTE pvDecoded = new BYTE[cBlocks * dwSrcBlockSize];
if( !pvDecoded )
return FALSE;
// Find the decoder
LPFNIMAADPCMCONVERT pfnOppConvert;
pfnOppConvert = apfnDecoders[m_wfxEncode.wfx.nChannels - 1];
// Encode the stream
if( !m_pfnConvert( (LPBYTE)pvSrc, (LPBYTE)pvDst, cBlocks, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ) )
{
delete[] pvDecoded;
return FALSE;
}
// Decode it back
if( !pfnOppConvert( (LPBYTE)pvDst, pvDecoded, cBlocks, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ) )
{
delete[] pvDecoded;
return FALSE;
}
// Report the normal difference
printf( "Difference between original and decoded streams: 0x%I64x\n",
CalcDifference( (LPBYTE)pvSrc, pvDecoded, cBlocks, cBlocks, dwSrcBlockSize ) );
delete[] pvDecoded;
}
break;
case CODEC_MODE_ENCODE_OPTIMIZE_WHOLE_FILE:
// Optimize whole file encode
// Encode the file with each possible starting step index
// and pick the best one
{
printf("Using whole file encoding...\n");
// Allocate temporary buffers
LPBYTE pvTempDst = new BYTE[cBlocks * dwDstBlockSize];
if(!pvTempDst)
return FALSE;
LPBYTE pvDecoded = new BYTE[cBlocks * dwSrcBlockSize];
if(!pvDecoded)
{
delete[] pvTempDst;
return FALSE;
}
// Find the decoder
LPFNIMAADPCMCONVERT pfnOppConvert;
pfnOppConvert = apfnDecoders[m_wfxEncode.wfx.nChannels - 1];
// Keep track of the best encoding, as well as the chosen step index
ULONGLONG ullLeastDiff = (ULONGLONG)-1;
UINT uChosen = (UINT)-1;
// Encode the entire stream with each step index and choose the best one
for( UINT i = 0; i < ARRAYSIZE(m_asStep); ++i )
{
ZeroMemory( pvTempDst, cBlocks * dwDstBlockSize );
ZeroMemory( pvDecoded, cBlocks * dwSrcBlockSize );
// Encode
m_nStepIndexL = m_nStepIndexR = i;
if( !m_pfnConvert( (LPBYTE)pvSrc, pvTempDst, cBlocks, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ) )
continue;
// Decode
if( !pfnOppConvert( pvTempDst, pvDecoded, cBlocks, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ) )
continue;
// Diff
ULONGLONG ullDiff = CalcDifference( (LPBYTE)pvSrc, pvDecoded, cBlocks, cBlocks, dwSrcBlockSize );
if( ullDiff < ullLeastDiff )
{
ullLeastDiff = ullDiff;
uChosen = i;
CopyMemory( (LPBYTE)pvDst, pvTempDst, cBlocks * dwDstBlockSize );
}
}
// Report the optimized difference
printf( "Difference between original and decoded streams: 0x%I64x\n", ullLeastDiff );
printf( "Step index chosen: %d\n", uChosen );
delete[] pvTempDst;
delete[] pvDecoded;
}
break;
case CODEC_MODE_ENCODE_OPTIMIZE_EACH_BLOCK:
// Optimize per block encode
// Encode each block within the file with each
// possible starting step index and pick the
// best one for each block
{
printf("Using per-block encoding\n\n");
// Allocate temporary buffers
LPBYTE pvTempDst = new BYTE[dwDstBlockSize];
if( !pvTempDst )
return FALSE;
LPBYTE pvDecoded = new BYTE[dwSrcBlockSize];
if( !pvDecoded )
{
delete[] pvTempDst;
return FALSE;
}
// Find the decoder
LPFNIMAADPCMCONVERT pfnOppConvert;
pfnOppConvert = apfnDecoders[m_wfxEncode.wfx.nChannels - 1];
// We keep track of the best step index of the previous block
// This enables us to search a small range of values close to
// this value (the size of 2*STEPINDEXSEARCHRANGE)
// To begin, the previous block's best step index was -1.
INT iPreviousBestStepIndex = -1;
for( UINT c = 0; c < cBlocks; ++c )
{
ULONGLONG ullLeastDiff = (ULONGLONG)-1;
INT iThisBestStepIndex = -1;
INT iStartIndex, iStopIndex;
// Setup the start/stop indices properly
if( iPreviousBestStepIndex == -1 )
{
// If the previous best step index is -1,
// then we haven't yet encoded a block. Search
// through the entire range of step indices,
// rather than just in a limited range
iStartIndex = 0;
iStopIndex = ARRAYSIZE( m_asStep );
}
else
{
// Keep the range of indices to search limited
// to around the previously chosen step index
iStartIndex = iPreviousBestStepIndex - STEPINDEXSEARCHRANGE;
iStopIndex = iPreviousBestStepIndex + STEPINDEXSEARCHRANGE + 1;
}
// Try each step index in the searchable range and choose the best one
// for this block
for( INT i = iStartIndex; i < iStopIndex; ++i )
{
// Don't consider anything out of range
if( i < 0 || i >= ARRAYSIZE( m_asStep ) )
continue;
// Zero out the temporary buffers
ZeroMemory( pvTempDst, dwDstBlockSize );
ZeroMemory( pvDecoded, dwSrcBlockSize );
// Encode
m_nStepIndexL = m_nStepIndexR = i;
if( !m_pfnConvert( (LPBYTE)pvSrc + c*dwSrcBlockSize, pvTempDst, 1, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ) )
continue;
// Decode
if( !pfnOppConvert( pvTempDst, pvDecoded, 1, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ) )
continue;
// Diff
ULONGLONG ullDiff = CalcDifference( (LPBYTE)pvSrc + c*dwSrcBlockSize, pvDecoded, 1, cBlocks, dwSrcBlockSize );
if( ullDiff < ullLeastDiff )
{
ullLeastDiff = ullDiff;
iThisBestStepIndex = i;
CopyMemory( (LPBYTE)pvDst + c*dwDstBlockSize, (LPBYTE)pvTempDst, dwDstBlockSize );
}
}
// Save the best step index for this block
iPreviousBestStepIndex = iThisBestStepIndex;
}
delete[] pvTempDst;
delete[] pvDecoded;
// Report on the optimized difference
pvDecoded = new BYTE[cBlocks * dwSrcBlockSize];
pfnOppConvert( (LPBYTE)pvDst, pvDecoded, cBlocks, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR );
printf( "Difference between original and decoded streams: 0x%I64x\n", CalcDifference( (LPBYTE)pvSrc, pvDecoded, cBlocks, cBlocks, dwSrcBlockSize ) );
delete[] pvDecoded;
}
break;
}
return TRUE;
}
/****************************************************************************
*
* Reset
*
* Description:
* Resets the conversion operation.
*
* Arguments:
* (void)
*
* Returns:
* (void)
*
****************************************************************************/
void
CImaAdpcmCodec::Reset
(
void
)
{
//
// Reset the stepping indices
//
m_nStepIndexL = m_nStepIndexR = 0;
}
/****************************************************************************
*
* GetEncodeAlignment
*
* Description:
* Gets the alignment of an encoded buffer.
*
* Arguments:
* (void)
*
* Returns:
* WORD: alignment, in bytes.
*
****************************************************************************/
WORD
CImaAdpcmCodec::GetEncodeAlignment
(
void
)
{
return m_wfxEncode.wfx.nBlockAlign;
}
/****************************************************************************
*
* GetDecodeAlignment
*
* Description:
* Gets the alignment of a decoded buffer.
*
* Arguments:
* (void)
*
* Returns:
* DWORD: alignment, in bytes.
*
****************************************************************************/
WORD
CImaAdpcmCodec::GetDecodeAlignment
(
void
)
{
return m_wfxEncode.wSamplesPerBlock * m_wfxEncode.wfx.nChannels * IMAADPCM_PCM_BITS_PER_SAMPLE / 8;
}
/****************************************************************************
*
* CalculateEncodeAlignment
*
* Description:
* Calculates an encoded data block alignment based on a PCM sample
* count and an alignment multiplier.
*
* Arguments:
* WORD [in]: channel count.
* WORD [in]: PCM samples per block.
*
* Returns:
* WORD: alignment, in bytes.
*
****************************************************************************/
WORD
CImaAdpcmCodec::CalculateEncodeAlignment
(
WORD nChannels,
WORD nSamplesPerBlock
)
{
const WORD nEncodedSampleBits = nChannels * IMAADPCM_BITS_PER_SAMPLE;
const WORD nHeaderBytes = nChannels * IMAADPCM_HEADER_LENGTH;
INT nBlockAlign;
//
// Calculate the raw block alignment that nSamplesPerBlock dictates. This
// value may include a partial encoded sample, so be sure to round up.
//
// Start with the samples-per-block, minus 1. The first sample is actually
// stored in the header.
//
nBlockAlign = nSamplesPerBlock - 1;
//
// Convert to encoded sample size
//
nBlockAlign *= nEncodedSampleBits;
nBlockAlign += 7;
nBlockAlign /= 8;
//
// The stereo encoder requires that there be at least two DWORDs to process
//
nBlockAlign += 7;
nBlockAlign /= 8;
nBlockAlign *= 8;
//
// Add the header
//
nBlockAlign += nHeaderBytes;
// We used an INT temporarily, but the final result should fit into a WORD
assert( nBlockAlign < 0xFFFF );
return (WORD)nBlockAlign;
}
/****************************************************************************
*
* CreatePcmFormat
*
* Description:
* Creates a PCM format descriptor.
*
* Arguments:
* WORD [in]: channel count.
* DWORD [in]: sampling rate.
* LPWAVEFORMATEX [out]: format descriptor.
*
* Returns:
* (void)
*
****************************************************************************/
void
CImaAdpcmCodec::CreatePcmFormat
(
WORD nChannels,
DWORD nSamplesPerSec,
LPWAVEFORMATEX pwfx
)
{
pwfx->wFormatTag = WAVE_FORMAT_PCM;
pwfx->nChannels = nChannels;
pwfx->nSamplesPerSec = nSamplesPerSec;
pwfx->nBlockAlign = nChannels * IMAADPCM_PCM_BITS_PER_SAMPLE / 8;
pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec;
pwfx->wBitsPerSample = IMAADPCM_PCM_BITS_PER_SAMPLE;
}
/****************************************************************************
*
* CreateImaAdpcmFormat
*
* Description:
* Creates an IMA ADPCM format descriptor.
*
* Arguments:
* WORD [in]: channel count.
* DWORD [in]: sampling rate.
* LPIMAADPCMWAVEFORMAT [out]: format descriptor.
*
* Returns:
* (void)
*
****************************************************************************/
void
CImaAdpcmCodec::CreateImaAdpcmFormat
(
WORD nChannels,
DWORD nSamplesPerSec,
WORD nSamplesPerBlock,
LPIMAADPCMWAVEFORMAT pwfx
)
{
pwfx->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
pwfx->wfx.nChannels = nChannels;
pwfx->wfx.nSamplesPerSec = nSamplesPerSec;
pwfx->wfx.nBlockAlign = CalculateEncodeAlignment(nChannels, nSamplesPerBlock);
pwfx->wfx.nAvgBytesPerSec = nSamplesPerSec * pwfx->wfx.nBlockAlign / nSamplesPerBlock;
pwfx->wfx.wBitsPerSample = IMAADPCM_BITS_PER_SAMPLE;
pwfx->wfx.cbSize = sizeof(*pwfx) - sizeof(pwfx->wfx);
pwfx->wSamplesPerBlock = nSamplesPerBlock;
}
/****************************************************************************
*
* IsValidPcmFormat
*
* Description:
* Validates a format structure.
*
* Arguments:
* LPCWAVEFORMATEX [in]: format.
*
* Returns:
* BOOL: TRUE on success.
*
****************************************************************************/
BOOL
CImaAdpcmCodec::IsValidPcmFormat
(
LPCWAVEFORMATEX pwfx
)
{
if(WAVE_FORMAT_PCM != pwfx->wFormatTag)
{
return FALSE;
}
if((pwfx->nChannels < 1) || (pwfx->nChannels > IMAADPCM_MAX_CHANNELS))
{
return FALSE;
}
if(IMAADPCM_PCM_BITS_PER_SAMPLE != pwfx->wBitsPerSample)
{
return FALSE;
}
if(pwfx->nChannels * pwfx->wBitsPerSample / 8 != pwfx->nBlockAlign)
{
return FALSE;
}
if(pwfx->nBlockAlign * pwfx->nSamplesPerSec != pwfx->nAvgBytesPerSec)
{
return FALSE;
}
return TRUE;
}
/****************************************************************************
*
* IsValidXboxAdpcmFormat
*
* Description:
* Validates a format structure.
*
* Arguments:
* LPCIMAADPCMWAVEFORMAT [in]: format.
*
* Returns:
* BOOL: TRUE on success.
*
****************************************************************************/
BOOL
CImaAdpcmCodec::IsValidImaAdpcmFormat
(
LPCIMAADPCMWAVEFORMAT pwfx
)
{
if(WAVE_FORMAT_XBOX_ADPCM != pwfx->wfx.wFormatTag)
{
return FALSE;
}
if(sizeof(*pwfx) - sizeof(pwfx->wfx) != pwfx->wfx.cbSize)
{
return FALSE;
}
if((pwfx->wfx.nChannels < 1) || (pwfx->wfx.nChannels > IMAADPCM_MAX_CHANNELS))
{
return FALSE;
}
if(IMAADPCM_BITS_PER_SAMPLE != pwfx->wfx.wBitsPerSample)
{
return FALSE;
}
if(CalculateEncodeAlignment(pwfx->wfx.nChannels, pwfx->wSamplesPerBlock) != pwfx->wfx.nBlockAlign)
{
return FALSE;
}
return TRUE;
}
/****************************************************************************
*
* CalcDifference
*
* Description:
* Calculates the error between two audio buffers. The error is clamped
* at (ULONGLONG)-1. Also, the error of a block acts as a percentage of
* the maximum possible contribution of a block.
*
* Arguments:
* LPBYTE [in]: First buffer
* LPBYTE [in]: Second buffer
* UINT [in]: Number of blocks-worth to compare
* UINT [in]: Total number of blocks being converted
* DWORD [in]: Size of a single block in bytes
*
* Returns:
* ULONGLONG: Difference of the two buffers
*
****************************************************************************/
ULONGLONG CImaAdpcmCodec::CalcDifference(LPBYTE pvBuffer1, LPBYTE pvBuffer2, UINT cBlocks, UINT cTotalBlocks, DWORD dwBlockSize)
{
ULONGLONG ullDiff = 0;
// Each block worth of error can contribute a maximum of this value
const ULONGLONG ullMaxBlockContribution = ( (ULONGLONG)-1 / cTotalBlocks );
// The maximum error in a block is
// (2^16)^2 * m_wfxEncode.wSamplesPerBlock
// = ( 1 << 32 ) * m_wfxEncode.wSamplesPerBlock
const ULONGLONG ullMaxBlockDiff = ( (ULONGLONG)1 << 32 ) * m_wfxEncode.wSamplesPerBlock;
// Now we go through the buffers sample by sample and find the difference
// on a block-by-block basis. The factored difference of a block is
// ullBlockDiff / ullMaxBlockDiff * ullMaxBlockContribution
for( UINT i = 0; i < cBlocks; ++i )
{
PSHORT pSamples1 = (PSHORT)(pvBuffer1 + i * dwBlockSize);
PSHORT pSamples2 = (PSHORT)(pvBuffer2 + i * dwBlockSize);
ULONGLONG ullBlockDiff = 0;
// Find the block difference
for( UINT j = 0; j < m_wfxEncode.wSamplesPerBlock; ++j )
{
ULONGLONG ullSampleDiff = (ULONGLONG)(pSamples2[j]) - (ULONGLONG)(pSamples1[j]);
ullBlockDiff += ( ullSampleDiff * ullSampleDiff );
}
// Assert that we didn't go over the maximum possible
assert( ullBlockDiff <= ullMaxBlockDiff );
// Add the contribution of this block to the error
ullDiff += (ULONGLONG)( ( (DOUBLE)ullBlockDiff / (DOUBLE)ullMaxBlockDiff ) * ullMaxBlockContribution );
}
assert( ullDiff <= cBlocks * ullMaxBlockContribution );
return ullDiff;
}
/****************************************************************************
*
* EncodeSample
*
* Description:
* Encodes a sample.
*
* Arguments:
* int [in]: the sample to be encoded.
* LPINT [in/out]: the predicted value of the sample.
* int [in]: the quantization step size used to encode the sample.
*
* Returns:
* int: the encoded ADPCM sample.
*
****************************************************************************/
int
CImaAdpcmCodec::EncodeSample
(
int nInputSample,
LPINT pnPredictedSample,
int nStepSize
)
{
int nPredictedSample;
LONG lDifference;
int nEncodedSample;
nPredictedSample = *pnPredictedSample;
lDifference = nInputSample - nPredictedSample;
nEncodedSample = 0;
if(lDifference < 0)
{
nEncodedSample = 8;
lDifference = -lDifference;
}
if(lDifference >= nStepSize)
{
nEncodedSample |= 4;
lDifference -= nStepSize;
}
nStepSize >>= 1;
if(lDifference >= nStepSize)
{
nEncodedSample |= 2;
lDifference -= nStepSize;
}
nStepSize >>= 1;
if(lDifference >= nStepSize)
{
nEncodedSample |= 1;
lDifference -= nStepSize;
}
if(nEncodedSample & 8)
{
nPredictedSample = nInputSample + lDifference - (nStepSize >> 1);
}
else
{
nPredictedSample = nInputSample - lDifference + (nStepSize >> 1);
}
if(nPredictedSample > 32767)
{
nPredictedSample = 32767;
}
else if(nPredictedSample < -32768)
{
nPredictedSample = -32768;
}
*pnPredictedSample = nPredictedSample;
return nEncodedSample;
}
/****************************************************************************
*
* DecodeSample
*
* Description:
* Decodes an encoded sample.
*
* Arguments:
* int [in]: the sample to be decoded.
* int [in]: the predicted value of the sample.
* int [i]: the quantization step size used to encode the sample.
*
* Returns:
* int: the decoded PCM sample.
*
****************************************************************************/
int
CImaAdpcmCodec::DecodeSample
(
int nEncodedSample,
int nPredictedSample,
int nStepSize
)
{
LONG lDifference;
LONG lNewSample;
lDifference = nStepSize >> 3;
if(nEncodedSample & 4)
{
lDifference += nStepSize;
}
if(nEncodedSample & 2)
{
lDifference += nStepSize >> 1;
}
if(nEncodedSample & 1)
{
lDifference += nStepSize >> 2;
}
if(nEncodedSample & 8)
{
lDifference = -lDifference;
}
lNewSample = nPredictedSample + lDifference;
if((LONG)(short)lNewSample != lNewSample)
{
if(lNewSample < -32768)
{
lNewSample = -32768;
}
else
{
lNewSample = 32767;
}
}
return (int)lNewSample;
}
/****************************************************************************
*
* Conversion Routines
*
* Description:
* Converts a PCM buffer to ADPCM, or the reverse.
*
* Arguments:
* LPBYTE [in]: source buffer.
* LPBYTE [out]: destination buffer.
* UINT [in]: block count.
* UINT [in]: block alignment of the ADPCM data, in bytes.
* UINT [in]: the number of samples in each ADPCM block (not used in
* decoding).
* LPINT [in/out]: left-channel stepping index.
* LPINT [in/out]: right-channel stepping index.
*
* Returns:
* BOOL: TRUE on success.
*
****************************************************************************/
BOOL
CImaAdpcmCodec::EncodeM16
(
LPBYTE pbSrc,
LPBYTE pbDst,
UINT cBlocks,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
LPINT pnStepIndexL,
LPINT
)
{
LPBYTE pbBlock;
UINT cSamples;
int nSample;
int nStepSize;
int nEncSample1;
int nEncSample2;
int nPredSample;
int nStepIndex;
//
// Save a local copy of the step index so we're not constantly
// dereferencing a pointer.
//
nStepIndex = *pnStepIndexL;
//
// Enter the main loop
//
while(cBlocks--)
{
pbBlock = pbDst;
cSamples = cSamplesPerBlock - 1;
//
// Block header
//
nPredSample = *(short *)pbSrc;
pbSrc += sizeof(short);
*(LONG *)pbBlock = MAKELONG(nPredSample, nStepIndex);
pbBlock += sizeof(LONG);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles). Note
// that if we don't have enough data to fill a complete byte, then
// we add a 0 nibble on the end.
//
while(cSamples)
{
//
// Sample 1
//
nSample = *(short *)pbSrc;
pbSrc += sizeof(short);
cSamples--;
nStepSize = m_asStep[nStepIndex];
nEncSample1 = EncodeSample(nSample, &nPredSample, nStepSize);
nStepIndex = NextStepIndex(nEncSample1, nStepIndex);
//
// Sample 2
//
if(cSamples)
{
nSample = *(short *)pbSrc;
pbSrc += sizeof(short);
cSamples--;
nStepSize = m_asStep[nStepIndex];
nEncSample2 = EncodeSample(nSample, &nPredSample, nStepSize);
nStepIndex = NextStepIndex(nEncSample2, nStepIndex);
}
else
{
nEncSample2 = 0;
}
//
// Write out encoded byte.
//
*pbBlock++ = (BYTE)(nEncSample1 | (nEncSample2 << 4));
}
//
// Skip padding
//
pbDst += nBlockAlignment;
}
//
// Restore the value of the step index to be used on the next buffer.
//
*pnStepIndexL = nStepIndex;
return TRUE;
}
BOOL
CImaAdpcmCodec::EncodeS16
(
LPBYTE pbSrc,
LPBYTE pbDst,
UINT cBlocks,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
LPINT pnStepIndexL,
LPINT pnStepIndexR
)
{
LPBYTE pbBlock;
UINT cSamples;
UINT cSubSamples;
int nSample;
int nStepSize;
DWORD dwLeft;
DWORD dwRight;
int nEncSampleL;
int nPredSampleL;
int nStepIndexL;
int nEncSampleR;
int nPredSampleR;
int nStepIndexR;
UINT i;
//
// Save a local copy of the step indices so we're not constantly
// dereferencing a pointer.
//
nStepIndexL = *pnStepIndexL;
nStepIndexR = *pnStepIndexR;
//
// Enter the main loop
//
while(cBlocks--)
{
pbBlock = pbDst;
cSamples = cSamplesPerBlock - 1;
//
// LEFT channel block header
//
nPredSampleL = *(short *)pbSrc;
pbSrc += sizeof(short);
*(LONG *)pbBlock = MAKELONG(nPredSampleL, nStepIndexL);
pbBlock += sizeof(LONG);
//
// RIGHT channel block header
//
nPredSampleR = *(short *)pbSrc;
pbSrc += sizeof(short);
*(LONG *)pbBlock = MAKELONG(nPredSampleR, nStepIndexR);
pbBlock += sizeof(LONG);
//
// We have written the header for this block--now write the data
// chunk. This consists of 8 left samples (one DWORD of output)
// followed by 8 right samples (also one DWORD). Since the input
// samples are interleaved, we create the left and right DWORDs
// sample by sample, and then write them both out.
//
while(cSamples)
{
dwLeft = 0;
dwRight = 0;
cSubSamples = min(cSamples, 8);
for(i = 0; i < cSubSamples; i++)
{
//
// LEFT channel
//
nSample = *(short *)pbSrc;
pbSrc += sizeof(short);
nStepSize = m_asStep[nStepIndexL];
nEncSampleL = EncodeSample(nSample, &nPredSampleL, nStepSize);
nStepIndexL = NextStepIndex(nEncSampleL, nStepIndexL);
dwLeft |= (DWORD)nEncSampleL << (4 * i);
//
// RIGHT channel
//
nSample = *(short *)pbSrc;
pbSrc += sizeof(short);
nStepSize = m_asStep[nStepIndexR];
nEncSampleR = EncodeSample(nSample, &nPredSampleR, nStepSize);
nStepIndexR = NextStepIndex(nEncSampleR, nStepIndexR);
dwRight |= (DWORD)nEncSampleR << (4 * i);
}
//
// Write out encoded DWORDs.
//
*(LPDWORD)pbBlock = dwLeft;
pbBlock += sizeof(DWORD);
*(LPDWORD)pbBlock = dwRight;
pbBlock += sizeof(DWORD);
cSamples -= cSubSamples;
}
//
// Skip padding
//
pbDst += nBlockAlignment;
}
//
// Restore the value of the step index to be used on the next buffer.
//
*pnStepIndexL = nStepIndexL;
*pnStepIndexR = nStepIndexR;
return TRUE;
}
BOOL
CImaAdpcmCodec::DecodeM16
(
LPBYTE pbSrc,
LPBYTE pbDst,
UINT cBlocks,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
LPINT,
LPINT
)
{
BOOL fSuccess = TRUE;
LPBYTE pbBlock;
UINT cSamples;
BYTE bSample;
int nStepSize;
int nEncSample;
int nPredSample;
int nStepIndex;
DWORD dwHeader;
//
// Enter the main loop
//
while(cBlocks--)
{
pbBlock = pbSrc;
cSamples = cSamplesPerBlock - 1;
//
// Block header
//
dwHeader = *(LPDWORD)pbBlock;
pbBlock += sizeof(DWORD);
nPredSample = (int)(short)LOWORD(dwHeader);
nStepIndex = (int)(BYTE)HIWORD(dwHeader);
if(!ValidStepIndex(nStepIndex))
{
//
// The step index is out of range - this is considered a fatal
// error as the input stream is corrupted. We fail by returning
// zero bytes converted.
//
fSuccess = FALSE;
break;
}
//
// Write out first sample
//
*(short *)pbDst = (short)nPredSample;
pbDst += sizeof(short);
//
// Enter the block loop
//
while(cSamples)
{
bSample = *pbBlock++;
//
// Sample 1
//
nEncSample = (bSample & (BYTE)0x0F);
nStepSize = m_asStep[nStepIndex];
nPredSample = DecodeSample(nEncSample, nPredSample, nStepSize);
nStepIndex = NextStepIndex(nEncSample, nStepIndex);
*(short *)pbDst = (short)nPredSample;
pbDst += sizeof(short);
cSamples--;
//
// Sample 2
//
if(cSamples)
{
nEncSample = (bSample >> 4);
nStepSize = m_asStep[nStepIndex];
nPredSample = DecodeSample(nEncSample, nPredSample, nStepSize);
nStepIndex = NextStepIndex(nEncSample, nStepIndex);
*(short *)pbDst = (short)nPredSample;
pbDst += sizeof(short);
cSamples--;
}
}
//
// Skip padding
//
pbSrc += nBlockAlignment;
}
return fSuccess;
}
BOOL
CImaAdpcmCodec::DecodeS16
(
LPBYTE pbSrc,
LPBYTE pbDst,
UINT cBlocks,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
LPINT,
LPINT
)
{
BOOL fSuccess = TRUE;
LPBYTE pbBlock;
UINT cSamples;
UINT cSubSamples;
int nStepSize;
DWORD dwHeader;
DWORD dwLeft;
DWORD dwRight;
int nEncSampleL;
int nPredSampleL;
int nStepIndexL;
int nEncSampleR;
int nPredSampleR;
int nStepIndexR;
UINT i;
//
// Enter the main loop
//
while(cBlocks--)
{
pbBlock = pbSrc;
cSamples = cSamplesPerBlock - 1;
//
// LEFT channel header
//
dwHeader = *(LPDWORD)pbBlock;
pbBlock += sizeof(DWORD);
nPredSampleL = (int)(short)LOWORD(dwHeader);
nStepIndexL = (int)(BYTE)HIWORD(dwHeader);
if(!ValidStepIndex(nStepIndexL))
{
//
// The step index is out of range - this is considered a fatal
// error as the input stream is corrupted. We fail by returning
// zero bytes converted.
//
fSuccess = FALSE;
break;
}
//
// RIGHT channel header
//
dwHeader = *(LPDWORD)pbBlock;
pbBlock += sizeof(DWORD);
nPredSampleR = (int)(short)LOWORD(dwHeader);
nStepIndexR = (int)(BYTE)HIWORD(dwHeader);
if(!ValidStepIndex(nStepIndexR))
{
//
// The step index is out of range - this is considered a fatal
// error as the input stream is corrupted. We fail by returning
// zero bytes converted.
//
fSuccess = FALSE;
break;
}
//
// Write out first sample
//
*(LPDWORD)pbDst = MAKELONG(nPredSampleL, nPredSampleR);
pbDst += sizeof(DWORD);
//
// The first DWORD contains 4 left samples, the second DWORD
// contains 4 right samples. We process the source in 8-byte
// chunks to make it easy to interleave the output correctly.
//
while(cSamples)
{
dwLeft = *(LPDWORD)pbBlock;
pbBlock += sizeof(DWORD);
dwRight = *(LPDWORD)pbBlock;
pbBlock += sizeof(DWORD);
cSubSamples = min(cSamples, 8);
for(i = 0; i < cSubSamples; i++)
{
//
// LEFT channel
//
nEncSampleL = (dwLeft & 0x0F);
nStepSize = m_asStep[nStepIndexL];
nPredSampleL = DecodeSample(nEncSampleL, nPredSampleL, nStepSize);
nStepIndexL = NextStepIndex(nEncSampleL, nStepIndexL);
//
// RIGHT channel
//
nEncSampleR = (dwRight & 0x0F);
nStepSize = m_asStep[nStepIndexR];
nPredSampleR = DecodeSample(nEncSampleR, nPredSampleR, nStepSize);
nStepIndexR = NextStepIndex(nEncSampleR, nStepIndexR);
//
// Write out sample
//
*(LPDWORD)pbDst = MAKELONG(nPredSampleL, nPredSampleR);
pbDst += sizeof(DWORD);
//
// Shift the next input sample into the low-order 4 bits.
//
dwLeft >>= 4;
dwRight >>= 4;
}
cSamples -= cSubSamples;
}
//
// Skip padding
//
pbSrc += nBlockAlignment;
}
return fSuccess;
}
int XboxADPCMSize( int sampleCount, int channelCount, int sampleRate )
{
CImaAdpcmCodec codec;
IMAADPCMWAVEFORMAT wfxEncode;
// Create an APDCM format structure based off the source format
codec.CreateImaAdpcmFormat( (WORD)channelCount, sampleRate, XBOX_ADPCM_SAMPLES_PER_BLOCK, &wfxEncode );
// Calculate number of ADPCM blocks and length of ADPCM data
DWORD dwDestBlocks = sampleCount / XBOX_ADPCM_SAMPLES_PER_BLOCK;
DWORD dwDestLength = dwDestBlocks * wfxEncode.wfx.nBlockAlign;
return dwDestLength;
}
void Convert16ToXboxADPCM( const short *pInputBuffer, byte *pOutputBuffer, byte *pOutFormat, int sampleCount, int channelCount, int sampleRate )
{
CImaAdpcmCodec codec;
IMAADPCMWAVEFORMAT wfxEncode;
// Create an APDCM format structure based off the source format
codec.CreateImaAdpcmFormat( (WORD)channelCount, sampleRate, XBOX_ADPCM_SAMPLES_PER_BLOCK, &wfxEncode );
if ( pOutFormat )
{
memcpy( pOutFormat, &wfxEncode, sizeof(wfxEncode) );
}
// Initialize the codec
if ( FALSE == codec.Initialize( &wfxEncode, CODEC_MODE_ENCODE_OPTIMIZE_EACH_BLOCK ) )
{
printf( "Couldn't initialize codec.\n" );
return;
}
// Convert the data
DWORD dwDestBlocks = sampleCount / XBOX_ADPCM_SAMPLES_PER_BLOCK;
if ( FALSE == codec.Convert( (const byte *)pInputBuffer, pOutputBuffer, dwDestBlocks ) )
return;
}