haiku.git

#include "All.h"
#include "UnBitArrayBase.h"
#include "APEInfo.h"
#include "UnBitArray.h"


#undef	BACKWARDS_COMPATIBILITY

#ifdef BACKWARDS_COMPATIBILITY
	#include "Old/APEDecompressOld.h"
	#include "Old/UnBitArrayOld.h"
#endif


const uint32 POWERS_OF_TWO_MINUS_ONE[33] = {0u,1u,3u,7u,15u,31u,63u,127u,255u,
	511u,1023u,2047u,4095u,8191u,16383u,32767u,65535u,131071u,262143u,524287u,
	1048575u,2097151u,4194303u,8388607u,16777215u,33554431u,67108863u,
	134217727u,268435455u,536870911u,1073741823u,2147483647u,4294967295u};


CUnBitArrayBase*
CreateUnBitArray(IAPEDecompress* pAPEDecompress, int nVersion)
{
#ifdef BACKWARDS_COMPATIBILITY
	if (nVersion >= 3900)
		return static_cast<CUnBitArrayBase*>
			(new CUnBitArray(GET_IO(pAPEDecompress), nVersion));
	else
		return static_cast<CUnBitArrayBase*>
			(new CUnBitArrayOld(pAPEDecompress, nVersion));
#else
	return static_cast<CUnBitArrayBase*>
		(new CUnBitArray(GET_IO(pAPEDecompress), nVersion));
#endif
}


void
CUnBitArrayBase::AdvanceToByteBoundary() 
{
	int nMod = m_nCurrentBitIndex % 8;
	if (nMod != 0)
		m_nCurrentBitIndex += 8 - nMod;
}


uint32
CUnBitArrayBase::DecodeValueXBits(uint32 nBits) 
{
	// get more data if necessary
	if ((m_nCurrentBitIndex + nBits) >= m_nBits)
		FillBitArray();

	// variable declares
	uint32 nLeftBits = 32 - (m_nCurrentBitIndex & 31);
	uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5;
	m_nCurrentBitIndex += nBits;

	// if there isn't an overflow to the right value, get the value and exit
	if (nLeftBits >= nBits)
		return (m_pBitArray[nBitArrayIndex] 
			& (POWERS_OF_TWO_MINUS_ONE[nLeftBits])) >> (nLeftBits - nBits);

	// must get the "split" value from left and right
	int nRightBits = nBits - nLeftBits;
	uint32 nLeftValue = ((m_pBitArray[nBitArrayIndex]
		& POWERS_OF_TWO_MINUS_ONE[nLeftBits]) << nRightBits);
	uint32 nRightValue = (m_pBitArray[nBitArrayIndex + 1] >> (32 - nRightBits));
	return (nLeftValue | nRightValue);
}


int
CUnBitArrayBase::FillAndResetBitArray(int nFileLocation, int nNewBitIndex) 
{
	// reset the bit index
	m_nCurrentBitIndex = nNewBitIndex;

	// seek if necessary
	if (nFileLocation != -1 && m_pIO->Seek(nFileLocation, FILE_BEGIN) != 0)
		return ERROR_IO_READ;

    // read the new data into the bit array
	unsigned int nBytesRead = 0;
	if (m_pIO->Read((unsigned char*)m_pBitArray, m_nBytes, 
		&nBytesRead) != 0)
		return ERROR_IO_READ;
    return 0;
}


int
CUnBitArrayBase::FillBitArray() 
{
	// get the bit array index
	uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5;

	// move the remaining data to the front
	memmove((void *) (m_pBitArray),	static_cast<const void*>(m_pBitArray
		+ nBitArrayIndex), m_nBytes - (nBitArrayIndex * 4));

	// read the new data
	int nBytesToRead = nBitArrayIndex * 4;
	unsigned int nBytesRead = 0;
	int nRetVal = m_pIO->Read((unsigned char*)(m_pBitArray + m_nElements
		- nBitArrayIndex), nBytesToRead, &nBytesRead);

	// adjust the m_Bit pointer
	m_nCurrentBitIndex = m_nCurrentBitIndex & 31;

	// return
	return (nRetVal == 0) ? 0 : ERROR_IO_READ;
}


int
CUnBitArrayBase::CreateHelper(CIO * pIO, int nBytes, int nVersion)
{
	// check the parameters
	if ((pIO == NULL) || (nBytes <= 0))
		return ERROR_BAD_PARAMETER;

	// save the size
	m_nElements = nBytes / 4;
	m_nBytes = m_nElements * 4;
	m_nBits = m_nBytes * 8;

	// set the variables
	m_pIO = pIO;
	m_nVersion = nVersion;
	m_nCurrentBitIndex = 0;

	// create the bitarray
	m_pBitArray = new uint32[m_nElements];

	return (m_pBitArray != NULL) ? 0 : ERROR_INSUFFICIENT_MEMORY;
}