//==========================================================================;
//
// msadpcm.c
//
// Copyright (c) 1992-1994 Microsoft Corporation
//
// Description:
//
//
// History:
//
//==========================================================================;
#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <mmreg.h>
#include <msacm.h>
#include <msacmdrv.h>
#include "codec.h"
#include "msadpcm.h"
#include "debug.h"
//
// these are in dec386.asm for Win 16
//
// _gaiCoef1 dw 256, 512, 0, 192, 240, 460, 392
// _gaiCoef2 dw 0, -256, 0, 64, 0, -208, -232
//
// _gaiP4 dw 230, 230, 230, 230, 307, 409, 512, 614
// dw 768, 614, 512, 409, 307, 230, 230, 230
//
#ifdef WIN32
const int gaiCoef1[]= {256, 512, 0, 192, 240, 460, 392};
const int gaiCoef2[]= { 0, -256, 0, 64, 0, -208, -232};
const int gaiP4[] = {230, 230, 230, 230, 307, 409, 512, 614,
768, 614, 512, 409, 307, 230, 230, 230};
#endif
#ifndef INLINE
#define INLINE __inline
#endif
//--------------------------------------------------------------------------;
//
// DWORD pcmM08BytesToSamples
// DWORD pcmM16BytesToSamples
// DWORD pcmS08BytesToSamples
// DWORD pcmS16BytesToSamples
//
// Description:
// These functions return the number of samples in a buffer of PCM
// of the specified format. For efficiency, it is declared INLINE.
// Note that, depending on the optimization flags, it may not
// actually be implemented as INLINE. Optimizing for speed (-Oxwt)
// will generally obey the INLINE specification.
//
// Arguments:
// DWORD cb: The length of the buffer, in bytes.
//
// Return (DWORD): The length of the buffer in samples.
//
//--------------------------------------------------------------------------;
INLINE DWORD pcmM08BytesToSamples( DWORD cb )
{
return cb;
}
INLINE DWORD pcmM16BytesToSamples( DWORD cb )
{
return cb / ((DWORD)2);
}
INLINE DWORD pcmS08BytesToSamples( DWORD cb )
{
return cb / ((DWORD)2);
}
INLINE DWORD pcmS16BytesToSamples( DWORD cb )
{
return cb / ((DWORD)4);
}
//--------------------------------------------------------------------------;
//
// int pcmRead08
// int pcmRead16
// int pcmRead16Unaligned
//
// Description:
// These functions read an 8 or 16 bit PCM value from the specified
// buffer. Note that the buffers are either HUGE or UNALIGNED in all
// cases. However, if a single 16-bit value crosses a segment boundary
// in Win16, then pcmRead16 will wrap around; use pcmRead16Unaligned
// instead.
//
// Arguments:
// HPBYTE pb: Pointer to the input buffer.
//
// Return (int): The PCM value converted to 16-bit format.
//
//--------------------------------------------------------------------------;
INLINE int pcmRead08( HPBYTE pb )
{
return ( (int)*pb - 128 ) << 8;
}
INLINE int pcmRead16( HPBYTE pb )
{
return (int)*(short HUGE_T *)pb;
}
#ifdef WIN32
#define pcmRead16Unaligned pcmRead16
#else
INLINE int pcmRead16Unaligned( HPBYTE pb )
{
return (int)(short)( ((WORD)*pb) | (((WORD)*(pb+1))<<8) );
}
#endif
//--------------------------------------------------------------------------;
//
// void pcmWrite08
// void pcmWrite16
// void pcmWrite16Unaligned
//
// Description:
// These functions write a PCM sample (a 16-bit integer) into the
// specified buffer in the appropriate format. Note that the buffers
// are either HUGE or UNALIGNED. However, if a single 16-bit value is
// written across a segment boundary, then pcmWrite16 will not handle
// it correctly; us pcmWrite16Unaligned instead.
//
// Arguments:
// HPBYTE pb: Pointer to the output buffer.
// int iSamp: The sample.
//
// Return (int): The PCM value converted to 16-bit format.
//
//--------------------------------------------------------------------------;
INLINE void pcmWrite08( HPBYTE pb, int iSamp )
{
*pb = (BYTE)((iSamp >> 8) + 128);
}
INLINE void pcmWrite16( HPBYTE pb, int iSamp )
{
*(short HUGE_T *)pb = (short)iSamp;
}
#ifdef WIN32
#define pcmWrite16Unaligned pcmWrite16
#else
INLINE void pcmWrite16Unaligned( HPBYTE pb, int iSamp )
{
*pb = (BYTE)( iSamp&0x00FF );
*(pb+1) = (BYTE)( iSamp>>8 );
}
#endif
//--------------------------------------------------------------------------;
//
// int adpcmCalcDelta
//
// Description:
// This function computes the next Adaptive Scale Factor (ASF) value
// based on the the current ASF and the current encoded sample.
//
// Arguments:
// int iEnc: The current encoded sample (as a signed integer).
// int iDelta: The current ASF.
//
// Return (int): The next ASF.
//
//--------------------------------------------------------------------------;
INLINE int adpcmCalcDelta
(
int iEnc,
int iDelta
)
{
int iNewDelta;
iNewDelta = (int)((gaiP4[iEnc&OUTPUT4MASK] * (long)iDelta) >> PSCALE);
if( iNewDelta < DELTA4MIN )
iNewDelta = DELTA4MIN;
return iNewDelta;
}
//--------------------------------------------------------------------------;
//
// long adpcmCalcPrediction
//
// Description:
// This function calculates the predicted sample value based on the
// previous two samples and the current coefficients.
//
// Arguments:
// int iSamp1: The previous decoded sample.
// int iCoef1: The coefficient for iSamp1.
// int iSamp2: The decoded sample before iSamp1.
// int iCoef2: The coefficient for iSamp2.
//
// Return (long): The predicted sample.
//
//--------------------------------------------------------------------------;
INLINE long adpcmCalcPrediction
(
int iSamp1,
int iCoef1,
int iSamp2,
int iCoef2
)
{
return ((long)iSamp1 * iCoef1 + (long)iSamp2 * iCoef2) >> CSCALE;
}
//--------------------------------------------------------------------------;
//
// int adpcmDecodeSample
//
// Description:
// This function decodes a single 4-bit encoded ADPCM sample. There
// are three steps:
//
// 1. Sign-extend the 4-bit iInput.
//
// 2. predict the next sample using the previous two
// samples and the predictor coefficients:
//
// Prediction = (iSamp1 * aiCoef1 + iSamp2 * iCoef2) / 256;
//
// 3. reconstruct the original PCM sample using the encoded
// sample (iInput), the Adaptive Scale Factor (aiDelta)
// and the prediction value computed in step 1 above.
//
// Sample = (iInput * iDelta) + Prediction;
//
// Arguments:
// int iSamp1: The previous decoded sample.
// int iCoef1: The coefficient for iSamp1.
// int iSamp2: The decoded sample before iSamp1.
// int iCoef2: The coefficient for iSamp2.
// int iInput: The current encoded sample (lower 4 bits).
// int iDelta: The current ASF.
//
// Return (int): The decoded sample.
//
//--------------------------------------------------------------------------;
INLINE int adpcmDecodeSample
(
int iSamp1,
int iCoef1,
int iSamp2,
int iCoef2,
int iInput,
int iDelta
)
{
long lSamp;
iInput = (int)( ((signed char)(iInput<<4)) >> 4 );
lSamp = ((long)iInput * iDelta) +
adpcmCalcPrediction(iSamp1,iCoef1,iSamp2,iCoef2);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
return (int)lSamp;
}
//--------------------------------------------------------------------------;
//
// int adpcmEncode4Bit_FirstDelta
//
// Description:
//
//
// Arguments:
//
//
// Return (short FNLOCAL):
//
//
// History:
// 1/27/93 cjp [curtisp]
//
//--------------------------------------------------------------------------;
INLINE int FNLOCAL adpcmEncode4Bit_FirstDelta
(
int iCoef1,
int iCoef2,
int iP5,
int iP4,
int iP3,
int iP2,
int iP1
)
{
long lTotal;
int iRtn;
long lTemp;
//
// use average of 3 predictions
//
lTemp = (((long)iP5 * iCoef2) + ((long)iP4 * iCoef1)) >> CSCALE;
lTotal = (lTemp > iP3) ? (lTemp - iP3) : (iP3 - lTemp);
lTemp = (((long)iP4 * iCoef2) + ((long)iP3 * iCoef1)) >> CSCALE;
lTotal += (lTemp > iP2) ? (lTemp - iP2) : (iP2 - lTemp);
lTemp = (((long)iP3 * iCoef2) + ((long)iP2 * iCoef1)) >> CSCALE;
lTotal += (lTemp > iP1) ? (lTemp - iP1) : (iP1 - lTemp);
//
// optimal iDelta is 1/4 of prediction error
//
iRtn = (int)(lTotal / 12);
if (iRtn < DELTA4MIN)
iRtn = DELTA4MIN;
return (iRtn);
} // adpcmEncode4Bit_FirstDelta()
//==========================================================================;
//
// NON-REALTIME ENCODE ROUTINES
//
//==========================================================================;
//--------------------------------------------------------------------------;
//
// DWORD adpcmEncode4Bit_M08_FullPass
// DWORD adpcmEncode4Bit_M16_FullPass
// DWORD adpcmEncode4Bit_S08_FullPass
// DWORD adpcmEncode4Bit_S16_FullPass
//
// Description:
// These functions encode a buffer of data from PCM to MS ADPCM in the
// specified format. These functions use a fullpass algorithm which
// tries each set of coefficients in order to determine which set
// produces the smallest coding error. The appropriate function is
// called once for each ACMDM_STREAM_CONVERT message received.
//
//
// Arguments:
//
//
// Return (DWORD): The number of bytes used in the destination buffer.
//
//--------------------------------------------------------------------------;
#define ENCODE_DELTA_LOOKAHEAD 5
DWORD FNGLOBAL adpcmEncode4Bit_M08_FullPass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
HPBYTE pbSrcThisBlock;
DWORD cSrcSamples;
UINT cBlockSamples;
int aiSamples[ENCODE_DELTA_LOOKAHEAD];
int aiFirstDelta[MSADPCM_MAX_COEFFICIENTS];
DWORD adwTotalError[MSADPCM_MAX_COEFFICIENTS];
int iCoef1;
int iCoef2;
int iSamp1;
int iSamp2;
int iDelta;
int iOutput1;
int iOutput2;
int iBestPredictor;
int iSample;
long lSamp;
long lError;
long lPrediction;
DWORD dw;
UINT i,n;
pbDstStart = pbDst;
cSrcSamples = pcmM08BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// We need the first ENCODE_DELTA_LOOKAHEAD samples in order to
// calculate the first iDelta value. Therefore we put these samples
// into a more accessible array: aiSamples[]. Note: if we don't
// have ENCODE_DELTA_LOOKAHEAD samples, we pretend that the samples
// that we don't have are actually zeros. This is important not
// only for the iDelta calculation, but also for the case where
// there is only 1 sample to encode ... in this case, there is not
// really enough data to complete the ADPCM block header, but since
// the two delay samples for the block header will be taken from
// the aiSamples[] array, iSamp1 [the second sample] will be taken
// as zero and there will no problem.
//
pbSrcThisBlock = pbSrc;
for (n = 0; n < ENCODE_DELTA_LOOKAHEAD; n++)
{
if( n < cBlockSamples )
aiSamples[n] = pcmRead08(pbSrcThisBlock++);
else
aiSamples[n] = 0;
}
//
// find the optimal predictor for each channel: to do this, we
// must step through and encode using each coefficient set (one
// at a time) and determine which one has the least error from
// the original data. the one with the least error is then used
// for the final encode (the 8th pass done below).
//
// NOTE: keeping the encoded data of the one that has the least
// error at all times is an obvious optimization that should be
// done. in this way, we only need to do 7 passes instead of 8.
//
for (i = 0; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
//
// Reset source pointer to the beginning of the block.
//
pbSrcThisBlock = pbSrc;
//
// Reset variables for this pass.
//
adwTotalError[i] = 0L;
iCoef1 = lpCoefSet[i].iCoef1;
iCoef2 = lpCoefSet[i].iCoef2;
//
// We need to choose the first iDelta--to do this, we need
// to look at the first few samples.
//
iDelta = adpcmEncode4Bit_FirstDelta(iCoef1, iCoef2,
aiSamples[0], aiSamples[1], aiSamples[2],
aiSamples[3], aiSamples[4]);
aiFirstDelta[i] = iDelta;
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrcThisBlock so that it keeps in sync.
//
iSamp1 = aiSamples[1];
iSamp2 = aiSamples[0];
pbSrcThisBlock += 2*sizeof(BYTE);
//
// now encode the rest of the PCM data in this block--note
// we start 2 samples ahead because the first two samples are
// simply copied into the ADPCM block header...
//
for (n = 2; n < cBlockSamples; n++)
{
//
// calculate the prediction based on the previous two
// samples
//
lPrediction = adpcmCalcPrediction( iSamp1, iCoef1,
iSamp2, iCoef2 );
//
// Grab the next sample to encode.
//
iSample = pcmRead08(pbSrcThisBlock++);
//
// encode it
//
lError = (long)iSample - lPrediction;
iOutput1 = (int)(lError / iDelta);
if (iOutput1 > OUTPUT4MAX)
iOutput1 = OUTPUT4MAX;
else if (iOutput1 < OUTPUT4MIN)
iOutput1 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput1);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput1,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
//
// keep a running status on the error for the current
// coefficient pair for this channel
//
lError = lSamp - iSample;
adwTotalError[i] += (lError * lError) >> 7;
}
}
//
// WHEW! we have now made 7 passes over the data and calculated
// the error for each--so it's time to find the one that produced
// the lowest error and use that predictor.
//
iBestPredictor = 0;
dw = adwTotalError[0];
for (i = 1; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
if (adwTotalError[i] < dw)
{
iBestPredictor = i;
dw = adwTotalError[i];
}
}
iCoef1 = lpCoefSet[iBestPredictor].iCoef1;
iCoef2 = lpCoefSet[iBestPredictor].iCoef2;
//
// grab first iDelta from our precomputed first deltas that we
// calculated above
//
iDelta = aiFirstDelta[iBestPredictor];
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrc so that it keeps in sync.
//
iSamp1 = aiSamples[1];
iSamp2 = aiSamples[0];
pbSrc += 2*sizeof(BYTE);
ASSERT( cBlockSamples != 1 );
cBlockSamples -= 2;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)iBestPredictor;
pcmWrite16Unaligned(pbDst,iDelta);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples>0 )
{
//
// Sample 1.
//
iSample = pcmRead08(pbSrc++);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1,iCoef1,iSamp2,iCoef2);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput1 = (int)(lError / iDelta);
if (iOutput1 > OUTPUT4MAX)
iOutput1 = OUTPUT4MAX;
else if (iOutput1 < OUTPUT4MIN)
iOutput1 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput1);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput1,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
//
// Sample 2.
//
if( cBlockSamples>0 ) {
iSample = pcmRead08(pbSrc++);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1,iCoef1,iSamp2,iCoef2);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput2 = (int)(lError / iDelta);
if (iOutput2 > OUTPUT4MAX)
iOutput2 = OUTPUT4MAX;
else if (iOutput2 < OUTPUT4MIN)
iOutput2 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput2);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput2,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
} else {
iOutput2 = 0;
}
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutput1&OUTPUT4MASK)<<4) |
(iOutput2&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_M08_FullPass()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_M16_FullPass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
HPBYTE pbSrcThisBlock;
DWORD cSrcSamples;
UINT cBlockSamples;
int aiSamples[ENCODE_DELTA_LOOKAHEAD];
int aiFirstDelta[MSADPCM_MAX_COEFFICIENTS];
DWORD adwTotalError[MSADPCM_MAX_COEFFICIENTS];
int iCoef1;
int iCoef2;
int iSamp1;
int iSamp2;
int iDelta;
int iOutput1;
int iOutput2;
int iBestPredictor;
int iSample;
long lSamp;
long lError;
long lPrediction;
DWORD dw;
UINT i,n;
pbDstStart = pbDst;
cSrcSamples = pcmM16BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// We need the first ENCODE_DELTA_LOOKAHEAD samples in order to
// calculate the first iDelta value. Therefore we put these samples
// into a more accessible array: aiSamples[]. Note: if we don't
// have ENCODE_DELTA_LOOKAHEAD samples, we pretend that the samples
// that we don't have are actually zeros. This is important not
// only for the iDelta calculation, but also for the case where
// there is only 1 sample to encode ... in this case, there is not
// really enough data to complete the ADPCM block header, but since
// the two delay samples for the block header will be taken from
// the aiSamples[] array, iSamp1 [the second sample] will be taken
// as zero and there will no problem.
//
pbSrcThisBlock = pbSrc;
for (n = 0; n < ENCODE_DELTA_LOOKAHEAD; n++)
{
if( n < cBlockSamples )
{
aiSamples[n] = pcmRead16(pbSrcThisBlock);
pbSrcThisBlock += sizeof(short);
}
else
aiSamples[n] = 0;
}
//
// find the optimal predictor for each channel: to do this, we
// must step through and encode using each coefficient set (one
// at a time) and determine which one has the least error from
// the original data. the one with the least error is then used
// for the final encode (the 8th pass done below).
//
// NOTE: keeping the encoded data of the one that has the least
// error at all times is an obvious optimization that should be
// done. in this way, we only need to do 7 passes instead of 8.
//
for (i = 0; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
//
// Reset source pointer to the beginning of the block.
//
pbSrcThisBlock = pbSrc;
//
// Reset variables for this pass.
//
adwTotalError[i] = 0L;
iCoef1 = lpCoefSet[i].iCoef1;
iCoef2 = lpCoefSet[i].iCoef2;
//
// We need to choose the first iDelta--to do this, we need
// to look at the first few samples.
//
iDelta = adpcmEncode4Bit_FirstDelta(iCoef1, iCoef2,
aiSamples[0], aiSamples[1], aiSamples[2],
aiSamples[3], aiSamples[4]);
aiFirstDelta[i] = iDelta;
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrcThisBlock so that it keeps in sync.
//
iSamp1 = aiSamples[1];
iSamp2 = aiSamples[0];
pbSrcThisBlock += 2*sizeof(short);
//
// now encode the rest of the PCM data in this block--note
// we start 2 samples ahead because the first two samples are
// simply copied into the ADPCM block header...
//
for (n = 2; n < cBlockSamples; n++)
{
//
// calculate the prediction based on the previous two
// samples
//
lPrediction = adpcmCalcPrediction( iSamp1, iCoef1,
iSamp2, iCoef2 );
//
// Grab the next sample to encode.
//
iSample = pcmRead16(pbSrcThisBlock);
pbSrcThisBlock += sizeof(short);
//
// encode it
//
lError = (long)iSample - lPrediction;
iOutput1 = (int)(lError / iDelta);
if (iOutput1 > OUTPUT4MAX)
iOutput1 = OUTPUT4MAX;
else if (iOutput1 < OUTPUT4MIN)
iOutput1 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput1);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput1,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
//
// keep a running status on the error for the current
// coefficient pair for this channel
//
lError = lSamp - iSample;
adwTotalError[i] += (lError * lError) >> 7;
}
}
//
// WHEW! we have now made 7 passes over the data and calculated
// the error for each--so it's time to find the one that produced
// the lowest error and use that predictor.
//
iBestPredictor = 0;
dw = adwTotalError[0];
for (i = 1; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
if (adwTotalError[i] < dw)
{
iBestPredictor = i;
dw = adwTotalError[i];
}
}
iCoef1 = lpCoefSet[iBestPredictor].iCoef1;
iCoef2 = lpCoefSet[iBestPredictor].iCoef2;
//
// grab first iDelta from our precomputed first deltas that we
// calculated above
//
iDelta = aiFirstDelta[iBestPredictor];
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrc so that it keeps in sync.
//
iSamp1 = aiSamples[1];
iSamp2 = aiSamples[0];
pbSrc += 2*sizeof(short);
ASSERT( cBlockSamples != 1 );
cBlockSamples -= 2;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)iBestPredictor;
pcmWrite16Unaligned(pbDst,iDelta);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples>0 )
{
//
// Sample 1.
//
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1,iCoef1,iSamp2,iCoef2);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput1 = (int)(lError / iDelta);
if (iOutput1 > OUTPUT4MAX)
iOutput1 = OUTPUT4MAX;
else if (iOutput1 < OUTPUT4MIN)
iOutput1 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput1);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput1,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
//
// Sample 2.
//
if( cBlockSamples>0 ) {
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1,iCoef1,iSamp2,iCoef2);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput2 = (int)(lError / iDelta);
if (iOutput2 > OUTPUT4MAX)
iOutput2 = OUTPUT4MAX;
else if (iOutput2 < OUTPUT4MIN)
iOutput2 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput2);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput2,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
} else {
iOutput2 = 0;
}
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutput1&OUTPUT4MASK)<<4) |
(iOutput2&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_M16_FullPass()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_S08_FullPass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
HPBYTE pbSrcThisBlock;
DWORD cSrcSamples;
UINT cBlockSamples;
int aiSamplesL[ENCODE_DELTA_LOOKAHEAD];
int aiSamplesR[ENCODE_DELTA_LOOKAHEAD];
int aiFirstDeltaL[MSADPCM_MAX_COEFFICIENTS];
int aiFirstDeltaR[MSADPCM_MAX_COEFFICIENTS];
DWORD adwTotalErrorL[MSADPCM_MAX_COEFFICIENTS];
DWORD adwTotalErrorR[MSADPCM_MAX_COEFFICIENTS];
int iCoef1;
int iCoef2;
int iCoef1L;
int iCoef2L;
int iSamp1L;
int iSamp2L;
int iDeltaL;
int iOutputL;
int iBestPredictorL;
int iCoef1R;
int iCoef2R;
int iSamp1R;
int iSamp2R;
int iDeltaR;
int iOutputR;
int iBestPredictorR;
int iSample;
long lSamp;
long lError;
long lPrediction;
DWORD dwL, dwR;
UINT i,n;
pbDstStart = pbDst;
cSrcSamples = pcmS08BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// We need the first ENCODE_DELTA_LOOKAHEAD samples in order to
// calculate the first iDelta value. Therefore we put these samples
// into a more accessible array: aiSamples[]. Note: if we don't
// have ENCODE_DELTA_LOOKAHEAD samples, we pretend that the samples
// that we don't have are actually zeros. This is important not
// only for the iDelta calculation, but also for the case where
// there is only 1 sample to encode ... in this case, there is not
// really enough data to complete the ADPCM block header, but since
// the two delay samples for the block header will be taken from
// the aiSamples[] array, iSamp1 [the second sample] will be taken
// as zero and there will no problem.
//
pbSrcThisBlock = pbSrc;
for (n = 0; n < ENCODE_DELTA_LOOKAHEAD; n++)
{
if( n < cBlockSamples )
{
aiSamplesL[n] = pcmRead08(pbSrcThisBlock++);
aiSamplesR[n] = pcmRead08(pbSrcThisBlock++);
}
else
{
aiSamplesL[n] = 0;
aiSamplesR[n] = 0;
}
}
//
// find the optimal predictor for each channel: to do this, we
// must step through and encode using each coefficient set (one
// at a time) and determine which one has the least error from
// the original data. the one with the least error is then used
// for the final encode (the 8th pass done below).
//
// NOTE: keeping the encoded data of the one that has the least
// error at all times is an obvious optimization that should be
// done. in this way, we only need to do 7 passes instead of 8.
//
for (i = 0; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
//
// Reset source pointer to the beginning of the block.
//
pbSrcThisBlock = pbSrc;
//
// Reset variables for this pass (coefs are the same for L, R).
//
adwTotalErrorL[i] = 0L;
adwTotalErrorR[i] = 0L;
iCoef1 = lpCoefSet[i].iCoef1;
iCoef2 = lpCoefSet[i].iCoef2;
//
// We need to choose the first iDelta--to do this, we need
// to look at the first few samples.
//
iDeltaL = adpcmEncode4Bit_FirstDelta(iCoef1, iCoef2,
aiSamplesL[0], aiSamplesL[1], aiSamplesL[2],
aiSamplesL[3], aiSamplesL[4]);
iDeltaR = adpcmEncode4Bit_FirstDelta(iCoef1, iCoef2,
aiSamplesR[0], aiSamplesR[1], aiSamplesR[2],
aiSamplesR[3], aiSamplesR[4]);
aiFirstDeltaL[i] = iDeltaL;
aiFirstDeltaR[i] = iDeltaR;
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrcThisBlock so that it keeps in sync.
//
iSamp1L = aiSamplesL[1];
iSamp1R = aiSamplesR[1];
iSamp2L = aiSamplesL[0];
iSamp2R = aiSamplesR[0];
pbSrcThisBlock += 2*sizeof(BYTE) * 2; // Last 2 = # of channels.
//
// now encode the rest of the PCM data in this block--note
// we start 2 samples ahead because the first two samples are
// simply copied into the ADPCM block header...
//
for (n = 2; n < cBlockSamples; n++)
{
//
// LEFT channel.
//
//
// calculate the prediction based on the previous two
// samples
//
lPrediction = adpcmCalcPrediction( iSamp1L, iCoef1,
iSamp2L, iCoef2 );
//
// Grab the next sample to encode.
//
iSample = pcmRead08(pbSrcThisBlock++);
//
// encode it
//
lError = (long)iSample - lPrediction;
iOutputL = (int)(lError / iDeltaL);
if (iOutputL > OUTPUT4MAX)
iOutputL = OUTPUT4MAX;
else if (iOutputL < OUTPUT4MIN)
iOutputL = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaL * iOutputL);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaL = adpcmCalcDelta(iOutputL,iDeltaL);
//
// Save updated delay samples.
//
iSamp2L = iSamp1L;
iSamp1L = (int)lSamp;
//
// keep a running status on the error for the current
// coefficient pair for this channel
//
lError = lSamp - iSample;
adwTotalErrorL[i] += (lError * lError) >> 7;
//
// RIGHT channel.
//
//
// calculate the prediction based on the previous two
// samples
//
lPrediction = adpcmCalcPrediction( iSamp1R, iCoef1,
iSamp2R, iCoef2 );
//
// Grab the next sample to encode.
//
iSample = pcmRead08(pbSrcThisBlock++);
//
// encode it
//
lError = (long)iSample - lPrediction;
iOutputR = (int)(lError / iDeltaR);
if (iOutputR > OUTPUT4MAX)
iOutputR = OUTPUT4MAX;
else if (iOutputR < OUTPUT4MIN)
iOutputR = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaR * iOutputR);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaR = adpcmCalcDelta(iOutputR,iDeltaR);
//
// Save updated delay samples.
//
iSamp2R = iSamp1R;
iSamp1R = (int)lSamp;
//
// keep a running status on the error for the current
// coefficient pair for this channel
//
lError = lSamp - iSample;
adwTotalErrorR[i] += (lError * lError) >> 7;
}
}
//
// WHEW! we have now made 7 passes over the data and calculated
// the error for each--so it's time to find the one that produced
// the lowest error and use that predictor.
//
iBestPredictorL = 0;
iBestPredictorR = 0;
dwL = adwTotalErrorL[0];
dwR = adwTotalErrorR[0];
for (i = 1; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
if (adwTotalErrorL[i] < dwL)
{
iBestPredictorL = i;
dwL = adwTotalErrorL[i];
}
if (adwTotalErrorR[i] < dwR)
{
iBestPredictorR = i;
dwR = adwTotalErrorR[i];
}
}
iCoef1L = lpCoefSet[iBestPredictorL].iCoef1;
iCoef1R = lpCoefSet[iBestPredictorR].iCoef1;
iCoef2L = lpCoefSet[iBestPredictorL].iCoef2;
iCoef2R = lpCoefSet[iBestPredictorR].iCoef2;
//
// grab first iDelta from our precomputed first deltas that we
// calculated above
//
iDeltaL = aiFirstDeltaL[iBestPredictorL];
iDeltaR = aiFirstDeltaR[iBestPredictorR];
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrc so that it keeps in sync.
//
iSamp1L = aiSamplesL[1];
iSamp1R = aiSamplesR[1];
iSamp2L = aiSamplesL[0];
iSamp2R = aiSamplesR[0];
pbSrc += 2*sizeof(BYTE) * 2; // Last 2 = # of channels.
ASSERT( cBlockSamples != 1 );
cBlockSamples -= 2;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)iBestPredictorL;
*pbDst++ = (BYTE)iBestPredictorR;
pcmWrite16Unaligned(pbDst,iDeltaL);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iDeltaR);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1R);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2R);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples-- )
{
//
// LEFT channel.
//
iSample = pcmRead08(pbSrc++);
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1L,iCoef1L,iSamp2L,iCoef2L);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputL = (int)(lError / iDeltaL);
if (iOutputL > OUTPUT4MAX)
iOutputL = OUTPUT4MAX;
else if (iOutputL < OUTPUT4MIN)
iOutputL = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaL * iOutputL);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaL = adpcmCalcDelta(iOutputL,iDeltaL);
//
// Save updated delay samples.
//
iSamp2L = iSamp1L;
iSamp1L = (int)lSamp;
//
// RIGHT channel.
//
iSample = pcmRead08(pbSrc++);
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1R,iCoef1R,iSamp2R,iCoef2R);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputR = (int)(lError / iDeltaR);
if (iOutputR > OUTPUT4MAX)
iOutputR = OUTPUT4MAX;
else if (iOutputR < OUTPUT4MIN)
iOutputR = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaR * iOutputR);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaR = adpcmCalcDelta(iOutputR,iDeltaR);
//
// Save updated delay samples.
//
iSamp2R = iSamp1R;
iSamp1R = (int)lSamp;
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutputL&OUTPUT4MASK)<<4) |
(iOutputR&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_S08_FullPass()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_S16_FullPass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
HPBYTE pbSrcThisBlock;
DWORD cSrcSamples;
UINT cBlockSamples;
int aiSamplesL[ENCODE_DELTA_LOOKAHEAD];
int aiSamplesR[ENCODE_DELTA_LOOKAHEAD];
int aiFirstDeltaL[MSADPCM_MAX_COEFFICIENTS];
int aiFirstDeltaR[MSADPCM_MAX_COEFFICIENTS];
DWORD adwTotalErrorL[MSADPCM_MAX_COEFFICIENTS];
DWORD adwTotalErrorR[MSADPCM_MAX_COEFFICIENTS];
int iCoef1;
int iCoef2;
int iCoef1L;
int iCoef2L;
int iSamp1L;
int iSamp2L;
int iDeltaL;
int iOutputL;
int iBestPredictorL;
int iCoef1R;
int iCoef2R;
int iSamp1R;
int iSamp2R;
int iDeltaR;
int iOutputR;
int iBestPredictorR;
int iSample;
long lSamp;
long lError;
long lPrediction;
DWORD dwL, dwR;
UINT i,n;
pbDstStart = pbDst;
cSrcSamples = pcmS16BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// We need the first ENCODE_DELTA_LOOKAHEAD samples in order to
// calculate the first iDelta value. Therefore we put these samples
// into a more accessible array: aiSamples[]. Note: if we don't
// have ENCODE_DELTA_LOOKAHEAD samples, we pretend that the samples
// that we don't have are actually zeros. This is important not
// only for the iDelta calculation, but also for the case where
// there is only 1 sample to encode ... in this case, there is not
// really enough data to complete the ADPCM block header, but since
// the two delay samples for the block header will be taken from
// the aiSamples[] array, iSamp1 [the second sample] will be taken
// as zero and there will no problem.
//
pbSrcThisBlock = pbSrc;
for (n = 0; n < ENCODE_DELTA_LOOKAHEAD; n++)
{
if( n < cBlockSamples )
{
aiSamplesL[n] = pcmRead16(pbSrcThisBlock);
pbSrcThisBlock += sizeof(short);
aiSamplesR[n] = pcmRead16(pbSrcThisBlock);
pbSrcThisBlock += sizeof(short);
}
else
{
aiSamplesL[n] = 0;
aiSamplesR[n] = 0;
}
}
//
// find the optimal predictor for each channel: to do this, we
// must step through and encode using each coefficient set (one
// at a time) and determine which one has the least error from
// the original data. the one with the least error is then used
// for the final encode (the 8th pass done below).
//
// NOTE: keeping the encoded data of the one that has the least
// error at all times is an obvious optimization that should be
// done. in this way, we only need to do 7 passes instead of 8.
//
for (i = 0; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
//
// Reset source pointer to the beginning of the block.
//
pbSrcThisBlock = pbSrc;
//
// Reset variables for this pass (coefs are the same for L, R).
//
adwTotalErrorL[i] = 0L;
adwTotalErrorR[i] = 0L;
iCoef1 = lpCoefSet[i].iCoef1;
iCoef2 = lpCoefSet[i].iCoef2;
//
// We need to choose the first iDelta--to do this, we need
// to look at the first few samples.
//
iDeltaL = adpcmEncode4Bit_FirstDelta(iCoef1, iCoef2,
aiSamplesL[0], aiSamplesL[1], aiSamplesL[2],
aiSamplesL[3], aiSamplesL[4]);
iDeltaR = adpcmEncode4Bit_FirstDelta(iCoef1, iCoef2,
aiSamplesR[0], aiSamplesR[1], aiSamplesR[2],
aiSamplesR[3], aiSamplesR[4]);
aiFirstDeltaL[i] = iDeltaL;
aiFirstDeltaR[i] = iDeltaR;
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrcThisBlock so that it keeps in sync.
//
iSamp1L = aiSamplesL[1];
iSamp1R = aiSamplesR[1];
iSamp2L = aiSamplesL[0];
iSamp2R = aiSamplesR[0];
pbSrcThisBlock += 2*sizeof(short) * 2; // Last 2 = # of channels.
//
// now encode the rest of the PCM data in this block--note
// we start 2 samples ahead because the first two samples are
// simply copied into the ADPCM block header...
//
for (n = 2; n < cBlockSamples; n++)
{
//
// LEFT channel.
//
//
// calculate the prediction based on the previous two
// samples
//
lPrediction = adpcmCalcPrediction( iSamp1L, iCoef1,
iSamp2L, iCoef2 );
//
// Grab the next sample to encode.
//
iSample = pcmRead16(pbSrcThisBlock);
pbSrcThisBlock += sizeof(short);
//
// encode it
//
lError = (long)iSample - lPrediction;
iOutputL = (int)(lError / iDeltaL);
if (iOutputL > OUTPUT4MAX)
iOutputL = OUTPUT4MAX;
else if (iOutputL < OUTPUT4MIN)
iOutputL = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaL * iOutputL);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaL = adpcmCalcDelta(iOutputL,iDeltaL);
//
// Save updated delay samples.
//
iSamp2L = iSamp1L;
iSamp1L = (int)lSamp;
//
// keep a running status on the error for the current
// coefficient pair for this channel
//
lError = lSamp - iSample;
adwTotalErrorL[i] += (lError * lError) >> 7;
//
// RIGHT channel.
//
//
// calculate the prediction based on the previous two
// samples
//
lPrediction = adpcmCalcPrediction( iSamp1R, iCoef1,
iSamp2R, iCoef2 );
//
// Grab the next sample to encode.
//
iSample = pcmRead16(pbSrcThisBlock);
pbSrcThisBlock += sizeof(short);
//
// encode it
//
lError = (long)iSample - lPrediction;
iOutputR = (int)(lError / iDeltaR);
if (iOutputR > OUTPUT4MAX)
iOutputR = OUTPUT4MAX;
else if (iOutputR < OUTPUT4MIN)
iOutputR = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaR * iOutputR);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaR = adpcmCalcDelta(iOutputR,iDeltaR);
//
// Save updated delay samples.
//
iSamp2R = iSamp1R;
iSamp1R = (int)lSamp;
//
// keep a running status on the error for the current
// coefficient pair for this channel
//
lError = lSamp - iSample;
adwTotalErrorR[i] += (lError * lError) >> 7;
}
}
//
// WHEW! we have now made 7 passes over the data and calculated
// the error for each--so it's time to find the one that produced
// the lowest error and use that predictor.
//
iBestPredictorL = 0;
iBestPredictorR = 0;
dwL = adwTotalErrorL[0];
dwR = adwTotalErrorR[0];
for (i = 1; i < MSADPCM_MAX_COEFFICIENTS; i++)
{
if (adwTotalErrorL[i] < dwL)
{
iBestPredictorL = i;
dwL = adwTotalErrorL[i];
}
if (adwTotalErrorR[i] < dwR)
{
iBestPredictorR = i;
dwR = adwTotalErrorR[i];
}
}
iCoef1L = lpCoefSet[iBestPredictorL].iCoef1;
iCoef1R = lpCoefSet[iBestPredictorR].iCoef1;
iCoef2L = lpCoefSet[iBestPredictorL].iCoef2;
iCoef2R = lpCoefSet[iBestPredictorR].iCoef2;
//
// grab first iDelta from our precomputed first deltas that we
// calculated above
//
iDeltaL = aiFirstDeltaL[iBestPredictorL];
iDeltaR = aiFirstDeltaR[iBestPredictorR];
//
// Set up first two samples - these have already been converted
// to 16-bit values in aiSamples[], but make sure to increment
// pbSrc so that it keeps in sync.
//
iSamp1L = aiSamplesL[1];
iSamp1R = aiSamplesR[1];
iSamp2L = aiSamplesL[0];
iSamp2R = aiSamplesR[0];
pbSrc += 2*sizeof(short) * 2; // Last 2 = # of channels.
ASSERT( cBlockSamples != 1 );
cBlockSamples -= 2;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)iBestPredictorL;
*pbDst++ = (BYTE)iBestPredictorR;
pcmWrite16Unaligned(pbDst,iDeltaL);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iDeltaR);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1R);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2R);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples-- )
{
//
// LEFT channel.
//
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1L,iCoef1L,iSamp2L,iCoef2L);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputL = (int)(lError / iDeltaL);
if (iOutputL > OUTPUT4MAX)
iOutputL = OUTPUT4MAX;
else if (iOutputL < OUTPUT4MIN)
iOutputL = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaL * iOutputL);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaL = adpcmCalcDelta(iOutputL,iDeltaL);
//
// Save updated delay samples.
//
iSamp2L = iSamp1L;
iSamp1L = (int)lSamp;
//
// RIGHT channel.
//
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
//
// calculate the prediction based on the previous two samples
//
lPrediction = adpcmCalcPrediction(iSamp1R,iCoef1R,iSamp2R,iCoef2R);
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputR = (int)(lError / iDeltaR);
if (iOutputR > OUTPUT4MAX)
iOutputR = OUTPUT4MAX;
else if (iOutputR < OUTPUT4MIN)
iOutputR = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaR * iOutputR);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaR = adpcmCalcDelta(iOutputR,iDeltaR);
//
// Save updated delay samples.
//
iSamp2R = iSamp1R;
iSamp1R = (int)lSamp;
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutputL&OUTPUT4MASK)<<4) |
(iOutputR&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_S16_FullPass()
//==========================================================================;
//
// The code below this point is only compiled into WIN32 builds. Win16
// builds will call 386 assembler routines instead; see the routine
// acmdStreamOpen() in codec.c for more details.
//
//==========================================================================;
#ifdef WIN32
//==========================================================================;
//
// REALTIME ENCODE ROUTINES
//
//==========================================================================;
//--------------------------------------------------------------------------;
//
// DWORD FNGLOBAL adpcmEncode4Bit_M08_OnePass
// DWORD FNGLOBAL adpcmEncode4Bit_M16_OnePass
// DWORD FNGLOBAL adpcmEncode4Bit_S08_OnePass
// DWORD FNGLOBAL adpcmEncode4Bit_S16_OnePass
//
// Description:
//
//
// Arguments:
//
//
// Return (DWORD FNGLOBAL):
//
//
// History:
// 1/27/93 cjp [curtisp]
// 3/03/94 rmh [bobhed]
//
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_M08_OnePass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
DWORD cSrcSamples;
UINT cBlockSamples;
int iSamp1;
int iSamp2;
int iDelta;
int iOutput1;
int iOutput2;
int iSample;
long lSamp;
long lError;
long lPrediction;
pbDstStart = pbDst;
cSrcSamples = pcmM08BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)1;
iDelta = DELTA4START;
pcmWrite16Unaligned(pbDst,DELTA4START); // Same as iDelta.
pbDst += sizeof(short);
//
// Note that iSamp2 comes before iSamp1. If we only have one
// sample, then set iSamp1 to zero.
//
iSamp2 = pcmRead08(pbSrc++);
if( --cBlockSamples > 0 ) {
iSamp1 = pcmRead08(pbSrc++);
cBlockSamples--;
} else {
iSamp1 = 0;
}
pcmWrite16Unaligned(pbDst,iSamp1);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples>0 )
{
//
// Sample 1.
//
iSample = pcmRead08(pbSrc++);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1<<1) - iSamp2;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput1 = (int)(lError / iDelta);
if (iOutput1 > OUTPUT4MAX)
iOutput1 = OUTPUT4MAX;
else if (iOutput1 < OUTPUT4MIN)
iOutput1 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput1);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput1,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
//
// Sample 2.
//
if( cBlockSamples>0 ) {
iSample = pcmRead08(pbSrc++);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1<<1) - iSamp2;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput2 = (int)(lError / iDelta);
if (iOutput2 > OUTPUT4MAX)
iOutput2 = OUTPUT4MAX;
else if (iOutput2 < OUTPUT4MIN)
iOutput2 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput2);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput2,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
} else {
iOutput2 = 0;
}
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutput1&OUTPUT4MASK)<<4) |
(iOutput2&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_M08_OnePass()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_M16_OnePass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
DWORD cSrcSamples;
UINT cBlockSamples;
int iSamp1;
int iSamp2;
int iDelta;
int iOutput1;
int iOutput2;
int iSample;
long lSamp;
long lError;
long lPrediction;
pbDstStart = pbDst;
cSrcSamples = pcmM16BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)1;
iDelta = DELTA4START;
pcmWrite16Unaligned(pbDst,DELTA4START); // Same as iDelta;
pbDst += sizeof(short);
//
// Note that iSamp2 comes before iSamp1. If we only have one
// sample, then set iSamp1 to zero.
//
iSamp2 = pcmRead16(pbSrc);
pbSrc += sizeof(short);
if( --cBlockSamples > 0 ) {
iSamp1 = pcmRead16(pbSrc);
pbSrc += sizeof(short);
cBlockSamples--;
} else {
iSamp1 = 0;
}
pcmWrite16Unaligned(pbDst,iSamp1);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples>0 )
{
//
// Sample 1.
//
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1<<1) - iSamp2;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput1 = (int)(lError / iDelta);
if (iOutput1 > OUTPUT4MAX)
iOutput1 = OUTPUT4MAX;
else if (iOutput1 < OUTPUT4MIN)
iOutput1 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput1);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput1,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
//
// Sample 2.
//
if( cBlockSamples>0 ) {
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
cBlockSamples--;
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1<<1) - iSamp2;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutput2 = (int)(lError / iDelta);
if (iOutput2 > OUTPUT4MAX)
iOutput2 = OUTPUT4MAX;
else if (iOutput2 < OUTPUT4MIN)
iOutput2 = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDelta * iOutput2);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDelta = adpcmCalcDelta(iOutput2,iDelta);
//
// Save updated delay samples.
//
iSamp2 = iSamp1;
iSamp1 = (int)lSamp;
} else {
iOutput2 = 0;
}
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutput1&OUTPUT4MASK)<<4) |
(iOutput2&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_M16_OnePass()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_S08_OnePass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
DWORD cSrcSamples;
UINT cBlockSamples;
int iSamp1L;
int iSamp2L;
int iDeltaL;
int iOutputL;
int iSamp1R;
int iSamp2R;
int iDeltaR;
int iOutputR;
int iSample;
long lSamp;
long lError;
long lPrediction;
pbDstStart = pbDst;
cSrcSamples = pcmS08BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)1;
*pbDst++ = (BYTE)1;
iDeltaL = DELTA4START;
iDeltaR = DELTA4START;
pcmWrite16Unaligned(pbDst,DELTA4START); // Same as iDeltaL.
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,DELTA4START); // Same as iDeltaR.
pbDst += sizeof(short);
//
// Note that iSamp2 comes before iSamp1. If we only have one
// sample, then set iSamp1 to zero.
//
iSamp2L = pcmRead08(pbSrc++);
iSamp2R = pcmRead08(pbSrc++);
if( --cBlockSamples > 0 ) {
iSamp1L = pcmRead08(pbSrc++);
iSamp1R = pcmRead08(pbSrc++);
cBlockSamples--;
} else {
iSamp1L = 0;
iSamp1R = 0;
}
pcmWrite16Unaligned(pbDst,iSamp1L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1R);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2R);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples-- )
{
//
// LEFT channel.
//
iSample = pcmRead08(pbSrc++);
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1L<<1) - iSamp2L;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputL = (int)(lError / iDeltaL);
if (iOutputL > OUTPUT4MAX)
iOutputL = OUTPUT4MAX;
else if (iOutputL < OUTPUT4MIN)
iOutputL = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaL * iOutputL);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaL = adpcmCalcDelta(iOutputL,iDeltaL);
//
// Save updated delay samples.
//
iSamp2L = iSamp1L;
iSamp1L = (int)lSamp;
//
// RIGHT channel.
//
iSample = pcmRead08(pbSrc++);
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1R<<1) - iSamp2R;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputR = (int)(lError / iDeltaR);
if (iOutputR > OUTPUT4MAX)
iOutputR = OUTPUT4MAX;
else if (iOutputR < OUTPUT4MIN)
iOutputR = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaR * iOutputR);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaR = adpcmCalcDelta(iOutputR,iDeltaR);
//
// Save updated delay samples.
//
iSamp2R = iSamp1R;
iSamp1R = (int)lSamp;
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutputL&OUTPUT4MASK)<<4) |
(iOutputR&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_S08_OnePass()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmEncode4Bit_S16_OnePass
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
DWORD cSrcSamples;
UINT cBlockSamples;
int iSamp1L;
int iSamp2L;
int iDeltaL;
int iOutputL;
int iSamp1R;
int iSamp2R;
int iDeltaR;
int iOutputR;
int iSample;
long lSamp;
long lError;
long lPrediction;
pbDstStart = pbDst;
cSrcSamples = pcmS16BytesToSamples(cbSrcLength);
//
// step through each block of PCM data and encode it to 4 bit ADPCM
//
while( 0 != cSrcSamples )
{
//
// determine how much data we should encode for this block--this
// will be cSamplesPerBlock until we hit the last chunk of PCM
// data that will not fill a complete block. so on the last block
// we only encode that amount of data remaining...
//
cBlockSamples = (UINT)min(cSrcSamples, cSamplesPerBlock);
cSrcSamples -= cBlockSamples;
//
// write the block header for the encoded data
//
// the block header is composed of the following data:
// 1 byte predictor per channel
// 2 byte delta per channel
// 2 byte first delayed sample per channel
// 2 byte second delayed sample per channel
//
*pbDst++ = (BYTE)1;
*pbDst++ = (BYTE)1;
iDeltaL = DELTA4START;
iDeltaR = DELTA4START;
pcmWrite16Unaligned(pbDst,DELTA4START); // Same as iDeltaL.
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,DELTA4START); // Same as iDeltaR.
pbDst += sizeof(short);
//
// Note that iSamp2 comes before iSamp1. If we only have one
// sample, then set iSamp1 to zero.
//
iSamp2L = pcmRead16(pbSrc);
pbSrc += sizeof(short);
iSamp2R = pcmRead16(pbSrc);
pbSrc += sizeof(short);
if( --cBlockSamples > 0 ) {
iSamp1L = pcmRead16(pbSrc);
pbSrc += sizeof(short);
iSamp1R = pcmRead16(pbSrc);
pbSrc += sizeof(short);
cBlockSamples--;
} else {
iSamp1L = 0;
iSamp1R = 0;
}
pcmWrite16Unaligned(pbDst,iSamp1L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp1R);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2L);
pbDst += sizeof(short);
pcmWrite16Unaligned(pbDst,iSamp2R);
pbDst += sizeof(short);
//
// We have written the header for this block--now write the data
// chunk (which consists of a bunch of encoded nibbles).
//
while( cBlockSamples-- )
{
//
// LEFT channel.
//
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1L<<1) - iSamp2L;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputL = (int)(lError / iDeltaL);
if (iOutputL > OUTPUT4MAX)
iOutputL = OUTPUT4MAX;
else if (iOutputL < OUTPUT4MIN)
iOutputL = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaL * iOutputL);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaL = adpcmCalcDelta(iOutputL,iDeltaL);
//
// Save updated delay samples.
//
iSamp2L = iSamp1L;
iSamp1L = (int)lSamp;
//
// RIGHT channel.
//
iSample = pcmRead16(pbSrc);
pbSrc += sizeof(short);
//
// calculate the prediction based on the previous two samples
//
lPrediction = ((long)iSamp1R<<1) - iSamp2R;
//
// encode the sample
//
lError = (long)iSample - lPrediction;
iOutputR = (int)(lError / iDeltaR);
if (iOutputR > OUTPUT4MAX)
iOutputR = OUTPUT4MAX;
else if (iOutputR < OUTPUT4MIN)
iOutputR = OUTPUT4MIN;
lSamp = lPrediction + ((long)iDeltaR * iOutputR);
if (lSamp > 32767)
lSamp = 32767;
else if (lSamp < -32768)
lSamp = -32768;
//
// compute the next iDelta
//
iDeltaR = adpcmCalcDelta(iOutputR,iDeltaR);
//
// Save updated delay samples.
//
iSamp2R = iSamp1R;
iSamp1R = (int)lSamp;
//
// Write out the encoded byte.
//
*pbDst++ = (BYTE)( ((iOutputL&OUTPUT4MASK)<<4) |
(iOutputR&OUTPUT4MASK) );
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmEncode4Bit_S16_OnePass()
//==========================================================================;
//
// DECODE ROUTINES
//
//==========================================================================;
//--------------------------------------------------------------------------;
//
// DWORD adpcmDecode4Bit_M08
// DWORD adpcmDecode4Bit_M16
// DWORD adpcmDecode4Bit_S08
// DWORD adpcmDecode4Bit_S16
//
// Description:
// These functions decode a buffer of data from MS ADPCM to PCM in the
// specified format. The appropriate function is called once for each
// ACMDM_STREAM_CONVERT message received.
//
//
// Arguments:
//
//
// Return (DWORD): The number of bytes used in the destination buffer.
//
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmDecode4Bit_M08
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
UINT cbHeader;
UINT cbBlockLength;
UINT nPredictor;
BYTE bSample;
int iInput;
int iSamp;
int iSamp1;
int iSamp2;
int iCoef1;
int iCoef2;
int iDelta;
pbDstStart = pbDst;
cbHeader = MSADPCM_HEADER_LENGTH * 1; // 1 = number of channels.
//
//
//
while( cbSrcLength >= cbHeader )
{
//
// We have at least enough data to read a full block header.
//
// the header looks like this:
// 1 byte predictor per channel (determines coefficients).
// 2 byte delta per channel
// 2 byte first sample per channel
// 2 byte second sample per channel
//
// this gives us (7 * bChannels) bytes of header information. note
// that as long as there is _at least_ (7 * bChannels) of header
// info, we will grab the two samples from the header. We figure
// out how much data we have in the rest of the block, ie. whether
// we have a full block or not. That way we don't have to test
// each sample to see if we have run out of data.
//
cbBlockLength = (UINT)min(cbSrcLength,nBlockAlignment);
cbSrcLength -= cbBlockLength;
cbBlockLength -= cbHeader;
//
// Process the block header.
//
nPredictor = (UINT)(BYTE)(*pbSrc++);
if( nPredictor >= nNumCoef )
{
//
// the predictor is out of range--this is considered a
// fatal error with the ADPCM data, so we fail by returning
// zero bytes decoded
//
return 0;
}
iCoef1 = lpCoefSet[nPredictor].iCoef1;
iCoef2 = lpCoefSet[nPredictor].iCoef2;
iDelta = pcmRead16Unaligned(pbSrc);
pbSrc += sizeof(short);
iSamp1 = pcmRead16Unaligned(pbSrc);
pbSrc += sizeof(short);
iSamp2 = pcmRead16Unaligned(pbSrc);
pbSrc += sizeof(short);
//
// write out first 2 samples.
//
// NOTE: the samples are written to the destination PCM buffer
// in the _reverse_ order that they are in the header block:
// remember that iSamp2 is the _previous_ sample to iSamp1.
//
pcmWrite08(pbDst,iSamp2);
pcmWrite08(pbDst,iSamp1);
//
// we now need to decode the 'data' section of the ADPCM block.
// this consists of packed 4 bit nibbles. The high-order nibble
// contains the first sample; the low-order nibble contains the
// second sample.
//
while( cbBlockLength-- )
{
bSample = *pbSrc++;
//
// Sample 1.
//
iInput = (int)(((signed char)bSample) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1,iCoef1,
iSamp2,iCoef2,
iInput,iDelta );
iDelta = adpcmCalcDelta( iInput,iDelta );
pcmWrite08(pbDst++,iSamp);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2 = iSamp1;
iSamp1 = iSamp;
//
// Sample 2.
//
iInput = (int)(((signed char)(bSample<<4)) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1,iCoef1,
iSamp2,iCoef2,
iInput,iDelta );
iDelta = adpcmCalcDelta( iInput,iDelta );
pcmWrite08(pbDst++,iSamp);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2 = iSamp1;
iSamp1 = iSamp;
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmDecode4Bit_M08()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmDecode4Bit_M16
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
UINT cbHeader;
UINT cbBlockLength;
UINT nPredictor;
BYTE bSample;
int iInput;
int iSamp;
int iSamp1;
int iSamp2;
int iCoef1;
int iCoef2;
int iDelta;
pbDstStart = pbDst;
cbHeader = MSADPCM_HEADER_LENGTH * 1; // 1 = number of channels.
//
//
//
while( cbSrcLength >= cbHeader )
{
//
// We have at least enough data to read a full block header.
//
// the header looks like this:
// 1 byte predictor per channel (determines coefficients).
// 2 byte delta per channel
// 2 byte first sample per channel
// 2 byte second sample per channel
//
// this gives us (7 * bChannels) bytes of header information. note
// that as long as there is _at least_ (7 * bChannels) of header
// info, we will grab the two samples from the header. We figure
// out how much data we have in the rest of the block, ie. whether
// we have a full block or not. That way we don't have to test
// each sample to see if we have run out of data.
//
cbBlockLength = (UINT)min(cbSrcLength,nBlockAlignment);
cbSrcLength -= cbBlockLength;
cbBlockLength -= cbHeader;
//
// Process the block header.
//
nPredictor = (UINT)(BYTE)(*pbSrc++);
if( nPredictor >= nNumCoef )
{
//
// the predictor is out of range--this is considered a
// fatal error with the ADPCM data, so we fail by returning
// zero bytes decoded
//
return 0;
}
iCoef1 = lpCoefSet[nPredictor].iCoef1;
iCoef2 = lpCoefSet[nPredictor].iCoef2;
iDelta = pcmRead16Unaligned(pbSrc);
pbSrc += sizeof(short);
iSamp1 = pcmRead16Unaligned(pbSrc);
pbSrc += sizeof(short);
iSamp2 = pcmRead16Unaligned(pbSrc);
pbSrc += sizeof(short);
//
// write out first 2 samples.
//
// NOTE: the samples are written to the destination PCM buffer
// in the _reverse_ order that they are in the header block:
// remember that iSamp2 is the _previous_ sample to iSamp1.
//
pcmWrite16(pbDst,iSamp2);
pbDst += sizeof(short);
pcmWrite16(pbDst,iSamp1);
pbDst += sizeof(short);
//
// we now need to decode the 'data' section of the ADPCM block.
// this consists of packed 4 bit nibbles. The high-order nibble
// contains the first sample; the low-order nibble contains the
// second sample.
//
while( cbBlockLength-- )
{
bSample = *pbSrc++;
//
// Sample 1.
//
iInput = (int)(((signed char)bSample) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1,iCoef1,
iSamp2,iCoef2,
iInput,iDelta );
iDelta = adpcmCalcDelta( iInput,iDelta );
pcmWrite16(pbDst,iSamp);
pbDst += sizeof(short);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2 = iSamp1;
iSamp1 = iSamp;
//
// Sample 2.
//
iInput = (int)(((signed char)(bSample<<4)) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1,iCoef1,
iSamp2,iCoef2,
iInput,iDelta );
iDelta = adpcmCalcDelta( iInput,iDelta );
pcmWrite16(pbDst,iSamp);
pbDst += sizeof(short);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2 = iSamp1;
iSamp1 = iSamp;
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmDecode4Bit_M16()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmDecode4Bit_S08
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
UINT cbHeader;
UINT cbBlockLength;
UINT nPredictor;
BYTE bSample;
int iInput;
int iSamp;
int iSamp1L;
int iSamp2L;
int iCoef1L;
int iCoef2L;
int iDeltaL;
int iSamp1R;
int iSamp2R;
int iCoef1R;
int iCoef2R;
int iDeltaR;
pbDstStart = pbDst;
cbHeader = MSADPCM_HEADER_LENGTH * 2; // 2 = number of channels.
//
//
//
while( cbSrcLength >= cbHeader )
{
//
// We have at least enough data to read a full block header.
//
// the header looks like this:
// 1 byte predictor per channel (determines coefficients).
// 2 byte delta per channel
// 2 byte first sample per channel
// 2 byte second sample per channel
//
// this gives us (7 * bChannels) bytes of header information. note
// that as long as there is _at least_ (7 * bChannels) of header
// info, we will grab the two samples from the header. We figure
// out how much data we have in the rest of the block, ie. whether
// we have a full block or not. That way we don't have to test
// each sample to see if we have run out of data.
//
cbBlockLength = (UINT)min(cbSrcLength,nBlockAlignment);
cbSrcLength -= cbBlockLength;
cbBlockLength -= cbHeader;
//
// Process the block header.
//
nPredictor = (UINT)(BYTE)(*pbSrc++); // Left.
if( nPredictor >= nNumCoef )
{
//
// the predictor is out of range--this is considered a
// fatal error with the ADPCM data, so we fail by returning
// zero bytes decoded
//
return 0;
}
iCoef1L = lpCoefSet[nPredictor].iCoef1;
iCoef2L = lpCoefSet[nPredictor].iCoef2;
nPredictor = (UINT)(BYTE)(*pbSrc++); // Right.
if( nPredictor >= nNumCoef )
{
//
// the predictor is out of range--this is considered a
// fatal error with the ADPCM data, so we fail by returning
// zero bytes decoded
//
return 0;
}
iCoef1R = lpCoefSet[nPredictor].iCoef1;
iCoef2R = lpCoefSet[nPredictor].iCoef2;
iDeltaL = pcmRead16Unaligned(pbSrc); // Left.
pbSrc += sizeof(short);
iDeltaR = pcmRead16Unaligned(pbSrc); // Right.
pbSrc += sizeof(short);
iSamp1L = pcmRead16Unaligned(pbSrc); // Left.
pbSrc += sizeof(short);
iSamp1R = pcmRead16Unaligned(pbSrc); // Right.
pbSrc += sizeof(short);
iSamp2L = pcmRead16Unaligned(pbSrc); // Left.
pbSrc += sizeof(short);
iSamp2R = pcmRead16Unaligned(pbSrc); // Right.
pbSrc += sizeof(short);
//
// write out first 2 samples (per channel).
//
// NOTE: the samples are written to the destination PCM buffer
// in the _reverse_ order that they are in the header block:
// remember that iSamp2 is the _previous_ sample to iSamp1.
//
pcmWrite08(pbDst++,iSamp2L);
pcmWrite08(pbDst++,iSamp2R);
pcmWrite08(pbDst++,iSamp1L);
pcmWrite08(pbDst++,iSamp1R);
//
// we now need to decode the 'data' section of the ADPCM block.
// this consists of packed 4 bit nibbles. The high-order nibble
// contains the left sample; the low-order nibble contains the
// right sample.
//
while( cbBlockLength-- )
{
bSample = *pbSrc++;
//
// Left sample.
//
iInput = (int)(((signed char)bSample) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1L,iCoef1L,
iSamp2L,iCoef2L,
iInput,iDeltaL );
iDeltaL = adpcmCalcDelta( iInput,iDeltaL );
pcmWrite08(pbDst++,iSamp);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2L = iSamp1L;
iSamp1L = iSamp;
//
// Right sample.
//
iInput = (int)(((signed char)(bSample<<4)) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1R,iCoef1R,
iSamp2R,iCoef2R,
iInput,iDeltaR );
iDeltaR = adpcmCalcDelta( iInput,iDeltaR );
pcmWrite08(pbDst++,iSamp);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2R = iSamp1R;
iSamp1R = iSamp;
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmDecode4Bit_S08()
//--------------------------------------------------------------------------;
//--------------------------------------------------------------------------;
DWORD FNGLOBAL adpcmDecode4Bit_S16
(
HPBYTE pbSrc,
DWORD cbSrcLength,
HPBYTE pbDst,
UINT nBlockAlignment,
UINT cSamplesPerBlock,
UINT nNumCoef,
LPADPCMCOEFSET lpCoefSet
)
{
HPBYTE pbDstStart;
UINT cbHeader;
UINT cbBlockLength;
UINT nPredictor;
BYTE bSample;
int iInput;
int iSamp;
int iSamp1L;
int iSamp2L;
int iCoef1L;
int iCoef2L;
int iDeltaL;
int iSamp1R;
int iSamp2R;
int iCoef1R;
int iCoef2R;
int iDeltaR;
pbDstStart = pbDst;
cbHeader = MSADPCM_HEADER_LENGTH * 2; // 2 = number of channels.
//
//
//
while( cbSrcLength >= cbHeader )
{
//
// We have at least enough data to read a full block header.
//
// the header looks like this:
// 1 byte predictor per channel (determines coefficients).
// 2 byte delta per channel
// 2 byte first sample per channel
// 2 byte second sample per channel
//
// this gives us (7 * bChannels) bytes of header information. note
// that as long as there is _at least_ (7 * bChannels) of header
// info, we will grab the two samples from the header. We figure
// out how much data we have in the rest of the block, ie. whether
// we have a full block or not. That way we don't have to test
// each sample to see if we have run out of data.
//
cbBlockLength = (UINT)min(cbSrcLength,nBlockAlignment);
cbSrcLength -= cbBlockLength;
cbBlockLength -= cbHeader;
//
// Process the block header.
//
nPredictor = (UINT)(BYTE)(*pbSrc++); // Left.
if( nPredictor >= nNumCoef )
{
//
// the predictor is out of range--this is considered a
// fatal error with the ADPCM data, so we fail by returning
// zero bytes decoded
//
return 0;
}
iCoef1L = lpCoefSet[nPredictor].iCoef1;
iCoef2L = lpCoefSet[nPredictor].iCoef2;
nPredictor = (UINT)(BYTE)(*pbSrc++); // Right.
if( nPredictor >= nNumCoef )
{
//
// the predictor is out of range--this is considered a
// fatal error with the ADPCM data, so we fail by returning
// zero bytes decoded
//
return 0;
}
iCoef1R = lpCoefSet[nPredictor].iCoef1;
iCoef2R = lpCoefSet[nPredictor].iCoef2;
iDeltaL = pcmRead16Unaligned(pbSrc); // Left.
pbSrc += sizeof(short);
iDeltaR = pcmRead16Unaligned(pbSrc); // Right.
pbSrc += sizeof(short);
iSamp1L = pcmRead16Unaligned(pbSrc); // Left.
pbSrc += sizeof(short);
iSamp1R = pcmRead16Unaligned(pbSrc); // Right.
pbSrc += sizeof(short);
iSamp2L = pcmRead16Unaligned(pbSrc); // Left.
pbSrc += sizeof(short);
iSamp2R = pcmRead16Unaligned(pbSrc); // Right.
pbSrc += sizeof(short);
//
// write out first 2 samples (per channel).
//
// NOTE: the samples are written to the destination PCM buffer
// in the _reverse_ order that they are in the header block:
// remember that iSamp2 is the _previous_ sample to iSamp1.
//
pcmWrite16(pbDst,iSamp2L);
pbDst += sizeof(short);
pcmWrite16(pbDst,iSamp2R);
pbDst += sizeof(short);
pcmWrite16(pbDst,iSamp1L);
pbDst += sizeof(short);
pcmWrite16(pbDst,iSamp1R);
pbDst += sizeof(short);
//
// we now need to decode the 'data' section of the ADPCM block.
// this consists of packed 4 bit nibbles. The high-order nibble
// contains the left sample; the low-order nibble contains the
// right sample.
//
while( cbBlockLength-- )
{
bSample = *pbSrc++;
//
// Left sample.
//
iInput = (int)(((signed char)bSample) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1L,iCoef1L,
iSamp2L,iCoef2L,
iInput,iDeltaL );
iDeltaL = adpcmCalcDelta( iInput,iDeltaL );
pcmWrite16(pbDst,iSamp);
pbDst += sizeof(short);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2L = iSamp1L;
iSamp1L = iSamp;
//
// Right sample.
//
iInput = (int)(((signed char)(bSample<<4)) >> 4); //Sign-extend.
iSamp = adpcmDecodeSample( iSamp1R,iCoef1R,
iSamp2R,iCoef2R,
iInput,iDeltaR );
iDeltaR = adpcmCalcDelta( iInput,iDeltaR );
pcmWrite16(pbDst,iSamp);
pbDst += sizeof(short);
//
// ripple our previous samples down making the new iSamp1
// equal to the sample we just decoded
//
iSamp2R = iSamp1R;
iSamp1R = iSamp;
}
}
//
// We return the number of bytes used in the destination. This is
// simply the difference in bytes from where we started.
//
return (DWORD)(pbDst - pbDstStart);
} // adpcmDecode4Bit_S16()
#endif