600 lines
16 KiB
C++
600 lines
16 KiB
C++
/* $Header: /cvs/root/winamp/vlb/bitbuffer.cpp,v 1.1 2009/04/28 20:21:08 audiodsp Exp $ */
|
|
|
|
/***************************************************************************\
|
|
*
|
|
* Copyright 2000-2002 Dolby Laboratories, Inc. All Rights
|
|
* Reserved. Do not copy. Do not distribute.
|
|
* Confidential information.
|
|
*
|
|
* (C) copyright Fraunhofer - IIS (1998)
|
|
* All Rights Reserved
|
|
*
|
|
* filename: bitbuffer.cpp
|
|
* project : MPEG-2 AAC Decoder
|
|
* contents/description: memory input class with transport format
|
|
*
|
|
\***************************************************************************/
|
|
|
|
#include "bitbuffer.h"
|
|
#include "streaminfo.h"
|
|
|
|
static const unsigned int Adts_Value_SyncWord = 0xFFF ;
|
|
static const unsigned int Adts_Value_SyncMSByte = 0xFF ;
|
|
static const unsigned int Adts_Value_MinHeaderLength = 56 ;
|
|
|
|
static const unsigned int Adts_Length_SyncWord = 12 ;
|
|
static const unsigned int Adts_Length_Id = 1 ;
|
|
static const unsigned int Adts_Length_Layer = 2 ;
|
|
static const unsigned int Adts_Length_ProtectionAbsent = 1 ;
|
|
static const unsigned int Adts_Length_Profile = 2 ;
|
|
static const unsigned int Adts_Length_SamplingFrequencyIndex = 4 ;
|
|
static const unsigned int Adts_Length_PrivateBit = 1 ;
|
|
static const unsigned int Adts_Length_ChannelConfiguration = 3 ;
|
|
static const unsigned int Adts_Length_OriginalCopy = 1 ;
|
|
static const unsigned int Adts_Length_Home = 1 ;
|
|
|
|
static const unsigned int Adts_Length_CopyrightIdentificationBit = 1 ;
|
|
static const unsigned int Adts_Length_CopyrightIdentificationStart = 1 ;
|
|
static const unsigned int Adts_Length_FrameLength = 13 ;
|
|
static const unsigned int Adts_Length_BufferFullness = 11 ;
|
|
static const unsigned int Adts_Length_NumberOfRawDataBlocksInFrame = 2 ;
|
|
|
|
static const unsigned int Adts_Length_CrcCheck = 16 ;
|
|
|
|
static char copyright_id[COPYRIGHT_SIZE];
|
|
static char copyright_id_temp[COPYRIGHT_SIZE];
|
|
static unsigned int cid_bitcount;
|
|
static unsigned int cid_bytecount;
|
|
|
|
DECLARE_EXCEPTION(ECRCError, AAC_CRCERROR, "CRC calculation failed");
|
|
DECLARE_EXCEPTION(EInputBufferError, AAC_INPUT_BUFFER_EMPTY, "No sync word found!");
|
|
DECLARE_EXCEPTION(ESyncError, AAC_SYNCERROR, "Synchronization Error!") ;
|
|
|
|
CDolbyBitBuffer::CDolbyBitBuffer ()
|
|
: CDolbyBitStream ()
|
|
{
|
|
m_IsADTSCompliant=true;
|
|
|
|
m_bFrameReadButNotDecoded = false;
|
|
|
|
Initialize () ;
|
|
}
|
|
|
|
CDolbyBitBuffer::~CDolbyBitBuffer()
|
|
{
|
|
}
|
|
|
|
void CDolbyBitBuffer::Initialize (void)
|
|
{
|
|
m_ValidBits = 0 ;
|
|
m_ReadOffset = 0 ;
|
|
m_BitCnt = 0 ;
|
|
m_BitNdx = 0 ;
|
|
|
|
m_EOF = false ;
|
|
|
|
for (int i = 0 ; i < BufferSize ; i++)
|
|
{
|
|
m_Buffer [i] = 0 ;
|
|
}
|
|
|
|
m_BlocksLeftInFrame = 0 ;
|
|
m_Markers = 0 ;
|
|
|
|
m_FrameCrcValue = InvalidCrcValue ;
|
|
|
|
cid_bitcount = BYTE_SIZE; // init copyright id bit counter
|
|
cid_bytecount = COPYRIGHT_SIZE; // inti copyright id byte counter
|
|
|
|
buffer_fullness = 0;
|
|
last_buffer_fullness = 0;
|
|
last_frame_length = 0;
|
|
bytes_skipped = 0;
|
|
hold_bytes_skipped = false;
|
|
number_of_raw_data_blocks_in_frame = 0;
|
|
}
|
|
|
|
long CDolbyBitBuffer::Get (int nBits)
|
|
{
|
|
unsigned short tmp, tmp1 ;
|
|
|
|
int nWordNdx = (m_BitNdx >> 4) << 1 ;
|
|
int nBitsAvail = 16 - (m_BitNdx & 15) ;
|
|
|
|
tmp = m_Buffer [nWordNdx] ;
|
|
tmp <<= 8 ;
|
|
tmp |= m_Buffer [nWordNdx + 1] ;
|
|
tmp <<= (m_BitNdx & 15) ;
|
|
|
|
if (nBits > nBitsAvail)
|
|
{
|
|
nWordNdx = (nWordNdx + 2) & (BufferSize - 1) ;
|
|
tmp1 = m_Buffer [nWordNdx] ;
|
|
tmp1 <<= 8 ;
|
|
tmp1 |= m_Buffer [nWordNdx + 1] ;
|
|
|
|
tmp1 >>= (16 - (m_BitNdx & 15)) ;
|
|
tmp |= tmp1 ;
|
|
}
|
|
|
|
tmp >>= (16 - nBits) ;
|
|
|
|
m_BitNdx = (m_BitNdx+nBits) & (BufferBits - 1) ;
|
|
m_BitCnt += nBits ;
|
|
m_ValidBits -= nBits ;
|
|
|
|
return tmp ;
|
|
}
|
|
|
|
void CDolbyBitBuffer::PushBack (int n)
|
|
{
|
|
m_BitCnt -= n ;
|
|
m_ValidBits += n ;
|
|
m_BitNdx = (m_BitNdx - n) & (BufferBits - 1) ;
|
|
}
|
|
|
|
void CDolbyBitBuffer::ByteAlign (void)
|
|
{
|
|
long alignment = m_BitCnt % 8 ;
|
|
|
|
if (alignment)
|
|
{
|
|
Get (8 - alignment) ;
|
|
}
|
|
|
|
m_BitCnt = 0 ;
|
|
}
|
|
|
|
bool CDolbyBitBuffer::IsDecodableFrame (CStreamInfo &info)
|
|
{
|
|
ByteAlign ();
|
|
|
|
if (FrameReadButNotDecoded())
|
|
{
|
|
ClearFrameReadButNotDecoded();
|
|
return true;
|
|
}
|
|
|
|
tryagain :
|
|
|
|
SetPositionMarker (AncillaryElementStart) ;
|
|
bytes_skipped += GetBitCount() >> 3;
|
|
|
|
if (m_ValidBits < Adts_Value_MinHeaderLength)
|
|
{
|
|
if (m_EOF) throw EEndOfFile () ;
|
|
else return false ;
|
|
}
|
|
|
|
|
|
/* Since the 1-bit ID must be 1 and the 2-bit layer must be 0, we can
|
|
* look for 15 bits of sync rather than just 12. We'll get 16 bits from the
|
|
* buffer and mask the top 15 bits for ease of readability.
|
|
*/
|
|
if ((Get(Adts_Length_SyncWord + 4) & 0xFFFE) != 0xFFF8)
|
|
{
|
|
PushBack (Adts_Length_SyncWord + 4) ;
|
|
|
|
while (m_ValidBits >> 3)
|
|
{
|
|
if (Get (8) == Adts_Value_SyncMSByte)
|
|
{
|
|
PushBack (8) ;
|
|
|
|
if ((Get(Adts_Length_SyncWord + 4) & 0xFFFE) == 0xFFF8)
|
|
{
|
|
PushBack (Adts_Length_SyncWord + 4) ;
|
|
goto tryagain ;
|
|
}
|
|
else
|
|
{
|
|
/* Push back 8 of the 16 bits we read. This will advance us by a byte. */
|
|
PushBack (Adts_Length_SyncWord - 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
// syncword not found in BitBuffer so accumulate
|
|
// bytes skipped before throwing an error
|
|
bytes_skipped += GetBitCount() >> 3;
|
|
|
|
// eaten up input
|
|
if (m_EOF)
|
|
{
|
|
throw EEndOfFile();
|
|
}
|
|
else
|
|
{
|
|
throw EInputBufferError();
|
|
}
|
|
}
|
|
|
|
/* Push back the 4 extra bits we read beyond the 12-bit sync word. */
|
|
PushBack(4);
|
|
|
|
// adts_fixed_header
|
|
|
|
id = Get (Adts_Length_Id) ;
|
|
layer = Get (Adts_Length_Layer) ;
|
|
protection_absent = Get (Adts_Length_ProtectionAbsent) ;
|
|
profile = Get (Adts_Length_Profile) ;
|
|
sampling_frequency_index = Get (Adts_Length_SamplingFrequencyIndex) ;
|
|
private_bit = Get (Adts_Length_PrivateBit) ;
|
|
channel_configuration = Get (Adts_Length_ChannelConfiguration) ;
|
|
original_copy = Get (Adts_Length_OriginalCopy) ;
|
|
home = Get (Adts_Length_Home) ;
|
|
|
|
// adts_variable_header
|
|
|
|
copyright_identification_bit = Get (Adts_Length_CopyrightIdentificationBit) ;
|
|
copyright_identification_start = Get (Adts_Length_CopyrightIdentificationStart) ;
|
|
frame_length = Get (Adts_Length_FrameLength) ;
|
|
buffer_fullness = Get (Adts_Length_BufferFullness) ;
|
|
number_of_raw_data_blocks_in_frame = Get (Adts_Length_NumberOfRawDataBlocksInFrame) ;
|
|
|
|
unsigned int i;
|
|
|
|
if ((m_ValidBits >> 3) < (frame_length - (Adts_Value_MinHeaderLength / 8)))
|
|
{
|
|
if (m_EOF)
|
|
throw EEndOfFile () ;
|
|
|
|
PushBack (Adts_Value_MinHeaderLength) ;
|
|
return false ;
|
|
}
|
|
|
|
SetPositionMarker (AncillaryElementStop) ;
|
|
|
|
// adts_error_check
|
|
|
|
if (!protection_absent)
|
|
{
|
|
m_FrameCrcValue = Get (Adts_Length_CrcCheck) ;
|
|
}
|
|
|
|
if (layer != 0)
|
|
{
|
|
return false ;
|
|
}
|
|
|
|
// // //
|
|
|
|
ByteAlign () ;
|
|
|
|
// // // Copy data from ADTS header to info structure
|
|
info.SetProtectionAbsent(protection_absent);
|
|
info.SetOriginalCopy(original_copy);
|
|
info.SetHome(home);
|
|
info.SetFrameLength(frame_length);
|
|
|
|
// Assemble copyright ID
|
|
if (copyright_identification_start)
|
|
{
|
|
cid_bitcount = 0;
|
|
cid_bytecount = 0;
|
|
for (i=0; i<COPYRIGHT_SIZE; i++)
|
|
copyright_id[i] = copyright_id_temp[i];
|
|
copyright_id_temp[cid_bytecount++] = copyright_identification_bit;
|
|
cid_bitcount++;
|
|
}
|
|
else
|
|
{
|
|
if (cid_bitcount++ < BYTE_SIZE && cid_bytecount < COPYRIGHT_SIZE)
|
|
{
|
|
copyright_id_temp[cid_bytecount] <<= 1 | (copyright_identification_bit & 1);
|
|
if (cid_bitcount >= BYTE_SIZE)
|
|
{
|
|
cid_bitcount = 0;
|
|
cid_bytecount++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// here, if counter overflow: delete copyright info
|
|
for (i=0; i<COPYRIGHT_SIZE; i++)
|
|
copyright_id[i] = 0;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < COPYRIGHT_SIZE; i++)
|
|
info.SetCopyrightID(copyright_id[i], i); // write copyright ID to info structure
|
|
|
|
|
|
unsigned int nextsync = m_BitNdx >> 3 ;
|
|
unsigned int header_length = 7 + (protection_absent ? 0 : 2) ;
|
|
nextsync += frame_length - header_length ;
|
|
nextsync %= BufferSize ;
|
|
|
|
// this is the only place where we assume the bitstream to be
|
|
// aligned on byte boundaries (which is true for software),
|
|
// maybe someday we might want to remove this restriction.
|
|
|
|
/* If a 'RIFF' header is detected (due to concatenated RIFF+ADTS files), look beyond it
|
|
* for the next ADTS sync.
|
|
*/
|
|
if (m_Buffer[nextsync] == 'R' &&
|
|
m_Buffer[(nextsync + 1) % BufferSize] == 'I' &&
|
|
m_Buffer[(nextsync + 2) % BufferSize] == 'F' &&
|
|
m_Buffer[(nextsync + 3) % BufferSize] == 'F'
|
|
)
|
|
{
|
|
bool bFoundDataChunk = true;
|
|
unsigned int uiMarker = nextsync;
|
|
|
|
while (m_Buffer[nextsync] != 'd' ||
|
|
m_Buffer[(nextsync + 1) % BufferSize] != 'a' ||
|
|
m_Buffer[(nextsync + 2) % BufferSize] != 't' ||
|
|
m_Buffer[(nextsync + 3) % BufferSize] != 'a'
|
|
)
|
|
{
|
|
nextsync = (nextsync + 1) % BufferSize;
|
|
|
|
if (nextsync == uiMarker)
|
|
{
|
|
/* We've gone all the way around our circular buffer without ever finding a 'data' chunk. */
|
|
bFoundDataChunk = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bFoundDataChunk)
|
|
{
|
|
/* Skip over data chunk ID and length. The next bytes should be our ADTS sync word. */
|
|
nextsync += 8;
|
|
nextsync %= BufferSize;
|
|
}
|
|
}
|
|
|
|
if (m_Buffer[nextsync] == Adts_Value_SyncMSByte && (m_Buffer[(nextsync + 1) % BufferSize] & 0xFE) == 0xF8)
|
|
{
|
|
if (info.GetRawSamplingRate ())
|
|
{
|
|
float flen = (float) (info.GetSamplesPerFrame () * (number_of_raw_data_blocks_in_frame + 1)) ;
|
|
float bitrate = (float) (8 * last_frame_length + 32 * (buffer_fullness - last_buffer_fullness)) ;
|
|
|
|
m_ActualBitrate += (unsigned int) (bitrate / (flen / info.GetRawSamplingRate ())) ;
|
|
|
|
last_buffer_fullness = buffer_fullness ;
|
|
last_frame_length = frame_length ;
|
|
|
|
info.SetBitRate (m_ActualBitrate) ;
|
|
}
|
|
|
|
info.SetSamplingRateIndex (sampling_frequency_index) ;
|
|
info.SetProfile (profile) ;
|
|
info.SetChannelConfig (channel_configuration) ;
|
|
|
|
m_BlocksLeftInFrame = number_of_raw_data_blocks_in_frame ;
|
|
|
|
return true ;
|
|
}
|
|
else
|
|
{
|
|
if (!m_EOF)
|
|
{
|
|
// syncword not found in next frame, but
|
|
// current frame's header has already been
|
|
// read, so add it to the # of bytes skipped
|
|
bytes_skipped += header_length;
|
|
|
|
// hold on to the bytes skipped so that we can
|
|
// accumulate them across multiple calls to
|
|
// the function IsDecodableFrame
|
|
HoldBytesSkipped();
|
|
|
|
throw ESyncError();
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CDolbyBitBuffer::ClearBytesSkipped(void)
|
|
{
|
|
if (!hold_bytes_skipped)
|
|
{
|
|
bytes_skipped = 0;
|
|
}
|
|
else
|
|
{
|
|
// clear flag for next time around
|
|
hold_bytes_skipped = false;
|
|
}
|
|
}
|
|
|
|
|
|
void CDolbyBitBuffer::Feed (unsigned char pBuf [], unsigned int cbSize, unsigned int &cbValid)
|
|
{
|
|
pBuf = &pBuf [cbSize - cbValid] ;
|
|
|
|
unsigned int bTotal = 0 ;
|
|
|
|
unsigned int bToRead = (BufferBits - m_ValidBits) >> 3 ;
|
|
unsigned int noOfBytes = (bToRead < cbValid) ? bToRead : cbValid ;
|
|
|
|
while (noOfBytes > 0)
|
|
{
|
|
// split read to buffer size
|
|
|
|
bToRead = BufferSize - m_ReadOffset ;
|
|
bToRead = (bToRead < noOfBytes) ? bToRead : noOfBytes ;
|
|
|
|
// copy 'bToRead' bytes from 'ptr' to inputbuffer
|
|
|
|
for (unsigned int i = 0 ; i < bToRead ; i++)
|
|
{
|
|
m_Buffer [m_ReadOffset + i] = pBuf [i] ;
|
|
}
|
|
|
|
// add noOfBits to number of valid bits in buffer
|
|
|
|
m_ValidBits += bToRead * 8 ;
|
|
bTotal += bToRead ;
|
|
pBuf += bToRead ;
|
|
|
|
m_ReadOffset = (m_ReadOffset + bToRead) & (BufferSize - 1) ;
|
|
noOfBytes -= bToRead ;
|
|
}
|
|
|
|
cbValid -= bTotal ;
|
|
|
|
// invalidate crc markers
|
|
|
|
m_FrameCrcValue = InvalidCrcValue ;
|
|
m_Markers = 0 ;
|
|
}
|
|
|
|
// crc stuff
|
|
|
|
void CDolbyBitBuffer::SetPositionMarker (MarkerPosition position)
|
|
{
|
|
switch (position)
|
|
{
|
|
case SecondIndividualChannelStart :
|
|
|
|
m_Markers++ ;
|
|
|
|
case ChannelElementStart :
|
|
case AncillaryElementStart :
|
|
|
|
m_MarkerList [m_Markers] = CMarker (position, m_ValidBits, m_BitCnt, m_BitNdx) ;
|
|
|
|
break ;
|
|
|
|
case ChannelElementStop :
|
|
case AncillaryElementStop :
|
|
|
|
for (int i = 0 ; i < ((m_MarkerList [m_Markers].what == SecondIndividualChannelStart) ? 2 : 1) ; i++)
|
|
{
|
|
int delimiter = m_BitNdx + ((m_BitNdx > m_MarkerList [m_Markers - i].m_BitNdx) ? 0 : BufferBits) ;
|
|
m_MarkerList [m_Markers - i].m_elementBits = delimiter - m_MarkerList [m_Markers - i].m_BitNdx ;
|
|
}
|
|
|
|
m_Markers++ ;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
void CDolbyBitBuffer::IsCrcConsistent (unsigned int *crcValue)
|
|
{
|
|
if (m_FrameCrcValue == InvalidCrcValue)
|
|
return;
|
|
|
|
CMarker current (CurrentPosition, m_ValidBits, m_BitCnt, m_BitNdx) ;
|
|
|
|
*crcValue = 0xFFFF ;
|
|
|
|
for (unsigned int i = 0 ; i < m_Markers ; i++)
|
|
{
|
|
RestoreMarker (m_MarkerList [i]) ;
|
|
|
|
switch (m_MarkerList [i].what)
|
|
{
|
|
case ChannelElementStart :
|
|
|
|
UpdateCrc (*crcValue, m_MarkerList [i].m_elementBits, 192) ;
|
|
break ;
|
|
|
|
case SecondIndividualChannelStart :
|
|
|
|
UpdateCrc (*crcValue, m_MarkerList [i].m_elementBits, 128) ;
|
|
break ;
|
|
|
|
case AncillaryElementStart :
|
|
|
|
UpdateCrc (*crcValue, m_MarkerList [i].m_elementBits) ;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
RestoreMarker (current) ;
|
|
|
|
if (*crcValue != m_FrameCrcValue)
|
|
throw ECRCError();
|
|
|
|
return;
|
|
}
|
|
|
|
void CDolbyBitBuffer::UpdateCrc (unsigned int &crcValue, int numberOfBits, int minimumBits)
|
|
{
|
|
static const unsigned int HIGHBIT_MASK = 0x8000 ;
|
|
static const unsigned int CRC_POLY = 0x8005 ;
|
|
|
|
static const unsigned int crcTable [] =
|
|
{
|
|
0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
|
|
0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
|
|
0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
|
|
0x0050, 0x8055, 0x805f, 0x005a, 0x804b, 0x004e, 0x0044, 0x8041,
|
|
0x80c3, 0x00c6, 0x00cc, 0x80c9, 0x00d8, 0x80dd, 0x80d7, 0x00d2,
|
|
0x00f0, 0x80f5, 0x80ff, 0x00fa, 0x80eb, 0x00ee, 0x00e4, 0x80e1,
|
|
0x00a0, 0x80a5, 0x80af, 0x00aa, 0x80bb, 0x00be, 0x00b4, 0x80b1,
|
|
0x8093, 0x0096, 0x009c, 0x8099, 0x0088, 0x808d, 0x8087, 0x0082,
|
|
0x8183, 0x0186, 0x018c, 0x8189, 0x0198, 0x819d, 0x8197, 0x0192,
|
|
0x01b0, 0x81b5, 0x81bf, 0x01ba, 0x81ab, 0x01ae, 0x01a4, 0x81a1,
|
|
0x01e0, 0x81e5, 0x81ef, 0x01ea, 0x81fb, 0x01fe, 0x01f4, 0x81f1,
|
|
0x81d3, 0x01d6, 0x01dc, 0x81d9, 0x01c8, 0x81cd, 0x81c7, 0x01c2,
|
|
0x0140, 0x8145, 0x814f, 0x014a, 0x815b, 0x015e, 0x0154, 0x8151,
|
|
0x8173, 0x0176, 0x017c, 0x8179, 0x0168, 0x816d, 0x8167, 0x0162,
|
|
0x8123, 0x0126, 0x012c, 0x8129, 0x0138, 0x813d, 0x8137, 0x0132,
|
|
0x0110, 0x8115, 0x811f, 0x011a, 0x810b, 0x010e, 0x0104, 0x8101,
|
|
0x8303, 0x0306, 0x030c, 0x8309, 0x0318, 0x831d, 0x8317, 0x0312,
|
|
0x0330, 0x8335, 0x833f, 0x033a, 0x832b, 0x032e, 0x0324, 0x8321,
|
|
0x0360, 0x8365, 0x836f, 0x036a, 0x837b, 0x037e, 0x0374, 0x8371,
|
|
0x8353, 0x0356, 0x035c, 0x8359, 0x0348, 0x834d, 0x8347, 0x0342,
|
|
0x03c0, 0x83c5, 0x83cf, 0x03ca, 0x83db, 0x03de, 0x03d4, 0x83d1,
|
|
0x83f3, 0x03f6, 0x03fc, 0x83f9, 0x03e8, 0x83ed, 0x83e7, 0x03e2,
|
|
0x83a3, 0x03a6, 0x03ac, 0x83a9, 0x03b8, 0x83bd, 0x83b7, 0x03b2,
|
|
0x0390, 0x8395, 0x839f, 0x039a, 0x838b, 0x038e, 0x0384, 0x8381,
|
|
0x0280, 0x8285, 0x828f, 0x028a, 0x829b, 0x029e, 0x0294, 0x8291,
|
|
0x82b3, 0x02b6, 0x02bc, 0x82b9, 0x02a8, 0x82ad, 0x82a7, 0x02a2,
|
|
0x82e3, 0x02e6, 0x02ec, 0x82e9, 0x02f8, 0x82fd, 0x82f7, 0x02f2,
|
|
0x02d0, 0x82d5, 0x82df, 0x02da, 0x82cb, 0x02ce, 0x02c4, 0x82c1,
|
|
0x8243, 0x0246, 0x024c, 0x8249, 0x0258, 0x825d, 0x8257, 0x0252,
|
|
0x0270, 0x8275, 0x827f, 0x027a, 0x826b, 0x026e, 0x0264, 0x8261,
|
|
0x0220, 0x8225, 0x822f, 0x022a, 0x823b, 0x023e, 0x0234, 0x8231,
|
|
0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202
|
|
} ;
|
|
|
|
if (minimumBits && (numberOfBits > minimumBits))
|
|
numberOfBits = minimumBits ;
|
|
|
|
for (int bytes = 0 ; bytes < (numberOfBits >> 3) ; bytes++)
|
|
{
|
|
crcValue = ((crcValue << 8) & 0xFF00) ^ crcTable [((crcValue >> 8) ^ Get (8)) & 0x00FF] ;
|
|
}
|
|
|
|
for (int bits = 0 ; bits < (numberOfBits & 0x07) ; bits++)
|
|
{
|
|
int flag = ((crcValue & HIGHBIT_MASK) ? 1 : 0) ^ Get (1) ;
|
|
|
|
crcValue <<= 1 ;
|
|
crcValue &= 0xFFFF ;
|
|
|
|
if (flag) crcValue ^= CRC_POLY ;
|
|
}
|
|
|
|
if (minimumBits && (minimumBits > numberOfBits))
|
|
{
|
|
numberOfBits = minimumBits - numberOfBits ;
|
|
|
|
for (int bytes = 0 ; bytes < (numberOfBits >> 3) ; bytes++)
|
|
{
|
|
crcValue = ((crcValue << 8) & 0xFF00) ^ crcTable [(crcValue >> 8) & 0x00FF] ;
|
|
}
|
|
|
|
for (int bits = 0 ; bits < (numberOfBits & 0x07) ; bits++)
|
|
{
|
|
int flag = (crcValue & HIGHBIT_MASK) ? 1 : 0 ;
|
|
|
|
crcValue <<= 1 ;
|
|
crcValue &= 0xFFFF ;
|
|
|
|
if (flag) crcValue ^= CRC_POLY ;
|
|
}
|
|
}
|
|
}
|