steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/vlb/bitbuffer.cpp

600 lines
16 KiB
C++
Raw Blame History

/* $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 ;
}
}
}
Reference in New Issue View Git Blame Copy Permalink