Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compiler warning fixes and code style cleanup. No Functional changes.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@37269 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Wim van der Meer 2010-06-27 03:02:48 +00:00
parent 216cd910b6
commit 23c0ae0362
6 changed files with 441 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/add-ons/media/plugins/ape_reader/MAClib/Prepare.cpp
View File

@ -47,7 +47,8 @@ const uint32 CRC32_TABLE[256] = {0u,1996959894u,3993919788u,2567524794u,
1567103746u,711928724u,3020668471u,3272380065u,1510334235u,755167117u};
int CPrepare::Prepare(const unsigned char* pRawData, int nBytes,
int
CPrepare::Prepare(const unsigned char* pRawData, int nBytes,
const WAVEFORMATEX* pWaveFormatEx, int* pOutputX, int* pOutputY,
unsigned int* pCRC, int* pSpecialCodes, int* pPeakLevel)
{
@ -255,7 +256,8 @@ int CPrepare::Prepare(const unsigned char* pRawData, int nBytes,
}
void CPrepare::Unprepare(int X, int Y, const WAVEFORMATEX* pWaveFormatEx,
void
CPrepare::Unprepare(int X, int Y, const WAVEFORMATEX* pWaveFormatEx,
unsigned char* pOutput, unsigned int* pCRC)
{
#define CALCULATE_CRC_BYTE *pCRC = (*pCRC >> 8) ^ CRC32_TABLE[(*pCRC & 0xFF) ^ *pOutput++];
@ -352,7 +354,8 @@ void CPrepare::Unprepare(int X, int Y, const WAVEFORMATEX* pWaveFormatEx,
#ifdef BACKWARDS_COMPATIBILITY
int CPrepare::UnprepareOld(int* pInputX, int* pInputY, int nBlocks,
int
CPrepare::UnprepareOld(int* pInputX, int* pInputY, int nBlocks,
const WAVEFORMATEX* pWaveFormatEx, unsigned char* pRawData,
unsigned int* pCRC, int* pSpecialCodes, int nFileVersion)
{

2
src/add-ons/media/plugins/ape_reader/MAClib/Prepare.h
View File

@ -1,6 +1,8 @@
#ifndef APE_PREPARE_H
#define APE_PREPARE_H
#include "NoWindows.h"
#define SPECIAL_FRAME_MONO_SILENCE 1
#define SPECIAL_FRAME_LEFT_SILENCE 1
#define SPECIAL_FRAME_RIGHT_SILENCE 2

475
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.cpp
View File

@ -6,296 +6,343 @@
#include "BitArray.h"
const uint32 POWERS_OF_TWO_MINUS_ONE_REVERSED[33] = {4294967295,2147483647,1073741823,536870911,268435455,134217727,67108863,33554431,16777215,8388607,4194303,2097151,1048575,524287,262143,131071,65535,32767,16383,8191,4095,2047,1023,511,255,127,63,31,15,7,3,1,0};
const uint32 POWERS_OF_TWO_MINUS_ONE_REVERSED[33] = {4294967295u,2147483647u,
1073741823u,536870911u,268435455u,134217727u,67108863u,33554431u,16777215u,
8388607u,4194303u,2097151u,1048575u,524287u,262143u,131071u,65535u,32767u,
16383u,8191u,4095u,2047u,1023u,511u,255u,127u,63u,31u,15u,7u,3u,1u,0u};
const uint32 K_SUM_MIN_BOUNDARY[32] = {0,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152,4194304,8388608,16777216,33554432,67108864,134217728,268435456,536870912,1073741824,2147483648,0,0,0,0};
const uint32 K_SUM_MIN_BOUNDARY[32] = {0u,32u,64u,128u,256u,512u,1024u,2048u,
4096u,8192u,16384u,32768u,65536u,131072u,262144u,524288u,1048576u,2097152u,
4194304u,8388608u,16777216u,33554432u,67108864u,134217728u,268435456u,
536870912u,1073741824u,2147483648u,0u,0u,0u,0u};
const uint32 RANGE_TOTAL_1[65] = {0,14824,28224,39348,47855,53994,58171,60926,62682,63786,64463,64878,65126,65276,65365,65419,65450,65469,65480,65487,65491,65493,65494,65495,65496,65497,65498,65499,65500,65501,65502,65503,65504,65505,65506,65507,65508,65509,65510,65511,65512,65513,65514,65515,65516,65517,65518,65519,65520,65521,65522,65523,65524,65525,65526,65527,65528,65529,65530,65531,65532,65533,65534,65535,65536};
const uint32 RANGE_WIDTH_1[64] = {14824,13400,11124,8507,6139,4177,2755,1756,1104,677,415,248,150,89,54,31,19,11,7,4,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
const uint32 RANGE_TOTAL_1[65] = {0u,14824u,28224u,39348u,47855u,53994u,58171u,
60926u,62682u,63786u,64463u,64878u,65126u,65276u,65365u,65419u,65450u,
65469u,65480u,65487u,65491u,65493u,65494u,65495u,65496u,65497u,65498u,
65499u,65500u,65501u,65502u,65503u,65504u,65505u,65506u,65507u,65508u,
65509u,65510u,65511u,65512u,65513u,65514u,65515u,65516u,65517u,65518u,
65519u,65520u,65521u,65522u,65523u,65524u,65525u,65526u,65527u,65528u,
65529u,65530u,65531u,65532u,65533u,65534u,65535u,65536u};
const uint32 RANGE_WIDTH_1[64] = {14824u,13400u,11124u,8507u,6139u,4177u,2755u,
1756u,1104u,677u,415u,248u,150u,89u,54u,31u,19u,11u,7u,4u,2u,1u,1u,1u,1u,1u,
1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,
1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u};
const uint32 RANGE_TOTAL_2[65] = {0,19578,36160,48417,56323,60899,63265,64435,64971,65232,65351,65416,65447,65466,65476,65482,65485,65488,65490,65491,65492,65493,65494,65495,65496,65497,65498,65499,65500,65501,65502,65503,65504,65505,65506,65507,65508,65509,65510,65511,65512,65513,65514,65515,65516,65517,65518,65519,65520,65521,65522,65523,65524,65525,65526,65527,65528,65529,65530,65531,65532,65533,65534,65535,65536};
const uint32 RANGE_WIDTH_2[64] = {19578,16582,12257,7906,4576,2366,1170,536,261,119,65,31,19,10,6,3,3,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,};
const uint32 RANGE_TOTAL_2[65] = {0u,19578u,36160u,48417u,56323u,60899u,63265u,
64435u,64971u,65232u,65351u,65416u,65447u,65466u,65476u,65482u,65485u,
65488u,65490u,65491u,65492u,65493u,65494u,65495u,65496u,65497u,65498u,
65499u,65500u,65501u,65502u,65503u,65504u,65505u,65506u,65507u,65508u,
65509u,65510u,65511u,65512u,65513u,65514u,65515u,65516u,65517u,65518u,
65519u,65520u,65521u,65522u,65523u,65524u,65525u,65526u,65527u,65528u,
65529u,65530u,65531u,65532u,65533u,65534u,65535u,65536u};
#define RANGE_OVERFLOW_TOTAL_WIDTH 65536
#define RANGE_OVERFLOW_SHIFT 16
const uint32 RANGE_WIDTH_2[64] = {19578u,16582u,12257u,7906u,4576u,2366u,1170u,
536u,261u,119u,65u,31u,19u,10u,6u,3u,3u,2u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,
1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,1u,
1u,1u,1u,1u,1u,1u,1u,1u,1u,1u};
#define CODE_BITS 32
#define TOP_VALUE ((unsigned int ) 1 << (CODE_BITS - 1))
#define SHIFT_BITS (CODE_BITS - 9)
#define EXTRA_BITS ((CODE_BITS - 2) % 8 + 1)
#define BOTTOM_VALUE (TOP_VALUE >> 8)
#define MODEL_ELEMENTS 64
#define RANGE_OVERFLOW_TOTAL_WIDTH 65536
#define RANGE_OVERFLOW_SHIFT 16
#define CODE_BITS 32
#define TOP_VALUE ((unsigned int ) 1 << (CODE_BITS - 1))
#define SHIFT_BITS (CODE_BITS - 9)
#define EXTRA_BITS ((CODE_BITS - 2) % 8 + 1)
#define BOTTOM_VALUE (TOP_VALUE >> 8)
#define MODEL_ELEMENTS 64
#if __GNUC__ != 2
using std::min;
using std::max;
#endif
/***********************************************************************************
Construction
***********************************************************************************/
CUnBitArray::CUnBitArray(CIO * pIO, int nVersion)
{
CreateHelper(pIO, 16384, nVersion);
m_nFlushCounter = 0;
m_nFinalizeCounter = 0;
CreateHelper(pIO, 16384, nVersion);
m_nFlushCounter = 0;
m_nFinalizeCounter = 0;
}
CUnBitArray::~CUnBitArray()
{
SAFE_ARRAY_DELETE(m_pBitArray)
SAFE_ARRAY_DELETE(m_pBitArray)
}
unsigned int CUnBitArray::DecodeValue(DECODE_VALUE_METHOD DecodeMethod, int nParam1, int nParam2)
unsigned int
CUnBitArray::DecodeValue(DECODE_VALUE_METHOD DecodeMethod, int nParam1,
int nParam2)
{
switch (DecodeMethod)
{
case DECODE_VALUE_METHOD_UNSIGNED_INT:
return DecodeValueXBits(32);
}
switch (DecodeMethod) {
case DECODE_VALUE_METHOD_UNSIGNED_INT:
return DecodeValueXBits(32);
case DECODE_VALUE_METHOD_UNSIGNED_RICE:
case DECODE_VALUE_METHOD_X_BITS:
break;
}
return 0;
return 0;
}
void CUnBitArray::GenerateArray(int * pOutputArray, int nElements, int nBytesRequired)
void
CUnBitArray::GenerateArray(int * pOutputArray, int nElements,
int nBytesRequired)
{
GenerateArrayRange(pOutputArray, nElements);
GenerateArrayRange(pOutputArray, nElements);
}
__inline unsigned char CUnBitArray::GetC()
__inline unsigned char
CUnBitArray::GetC()
{
unsigned char nValue = (unsigned char) (m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31)));
m_nCurrentBitIndex += 8;
return nValue;
uchar nValue = static_cast<uchar>(m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31)));
m_nCurrentBitIndex += 8;
return nValue;
}
__inline int CUnBitArray::RangeDecodeFast(int nShift)
__inline int
CUnBitArray::RangeDecodeFast(int nShift)
{
while (m_RangeCoderInfo.range <= BOTTOM_VALUE)
{
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
| ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
// decode
m_RangeCoderInfo.range = m_RangeCoderInfo.range >> nShift;
return m_RangeCoderInfo.low / m_RangeCoderInfo.range;
// decode
m_RangeCoderInfo.range = m_RangeCoderInfo.range >> nShift;
return m_RangeCoderInfo.low / m_RangeCoderInfo.range;
}
__inline int CUnBitArray::RangeDecodeFastWithUpdate(int nShift)
{
while (m_RangeCoderInfo.range <= BOTTOM_VALUE)
{
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
| ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
// decode
m_RangeCoderInfo.range = m_RangeCoderInfo.range >> nShift;
int nRetVal = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nRetVal;
return nRetVal;
// decode
m_RangeCoderInfo.range = m_RangeCoderInfo.range >> nShift;
int nRetVal = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nRetVal;
return nRetVal;
}
int CUnBitArray::DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState)
int
CUnBitArray::DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState)
{
// make sure there is room for the data
// this is a little slower than ensuring a huge block to start with, but it's safer
if (m_nCurrentBitIndex > m_nRefillBitThreshold)
{
FillBitArray();
}
// make sure there is room for the data
// this is a little slower than ensuring a huge block to start with,
// but it's safer
if (m_nCurrentBitIndex > m_nRefillBitThreshold)
FillBitArray();
int nValue = 0;
int nValue = 0;
if (m_nVersion >= 3990)
{
// figure the pivot value
int nPivotValue = max(BitArrayState.nKSum / 32, 1UL);
if (m_nVersion >= 3990) {
// figure the pivot value
int nPivotValue = max(BitArrayState.nKSum / 32, 1UL);
// get the overflow
int nOverflow = 0;
{
// decode
int nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT);
// get the overflow
int nOverflow = 0;
// lookup the symbol (must be a faster way than this)
while (nRangeTotal >= RANGE_TOTAL_2[nOverflow + 1]) { nOverflow++; }
// decode
uint32 nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT);
// update
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * RANGE_TOTAL_2[nOverflow];
m_RangeCoderInfo.range = m_RangeCoderInfo.range * RANGE_WIDTH_2[nOverflow];
// lookup the symbol (must be a faster way than this)
while (nRangeTotal >= RANGE_TOTAL_2[nOverflow + 1])
nOverflow++;
// get the working k
if (nOverflow == (MODEL_ELEMENTS - 1))
{
nOverflow = RangeDecodeFastWithUpdate(16);
nOverflow <<= 16;
nOverflow |= RangeDecodeFastWithUpdate(16);
}
}
// update
m_RangeCoderInfo.low -= m_RangeCoderInfo.range
* RANGE_TOTAL_2[nOverflow];
m_RangeCoderInfo.range = m_RangeCoderInfo.range
* RANGE_WIDTH_2[nOverflow];
// get the value
int nBase = 0;
{
int nShift = 0;
if (nPivotValue >= (1 << 16))
{
int nPivotValueBits = 0;
while ((nPivotValue >> nPivotValueBits) > 0) { nPivotValueBits++; }
int nSplitFactor = 1 << (nPivotValueBits - 16);
// get the working k
if (nOverflow == (MODEL_ELEMENTS - 1)) {
nOverflow = RangeDecodeFastWithUpdate(16);
nOverflow <<= 16;
nOverflow |= RangeDecodeFastWithUpdate(16);
}
int nPivotValueA = (nPivotValue / nSplitFactor) + 1;
int nPivotValueB = nSplitFactor;
// get the value
int nBase = 0;
while (m_RangeCoderInfo.range <= BOTTOM_VALUE)
{
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueA;
int nBaseA = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseA;
if (nPivotValue >= (1 << 16)) {
int nPivotValueBits = 0;
while ((nPivotValue >> nPivotValueBits) > 0)
nPivotValueBits++;
int nSplitFactor = 1 << (nPivotValueBits - 16);
int nPivotValueA = (nPivotValue / nSplitFactor) + 1;
int nPivotValueB = nSplitFactor;
while (m_RangeCoderInfo.range <= BOTTOM_VALUE)
{
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueB;
int nBaseB = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseB;
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
| ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueA;
int nBaseA = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseA;
nBase = nBaseA * nSplitFactor + nBaseB;
}
else
{
while (m_RangeCoderInfo.range <= BOTTOM_VALUE)
{
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
| ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueB;
int nBaseB = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseB;
// decode
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValue;
int nBaseLower = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseLower;
nBase = nBaseA * nSplitFactor + nBaseB;
} else {
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
| ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8;
}
nBase = nBaseLower;
}
}
// decode
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValue;
int nBaseLower = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseLower;
// build the value
nValue = nBase + (nOverflow * nPivotValue);
}
else
{
// decode
int nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT);
nBase = nBaseLower;
}
// lookup the symbol (must be a faster way than this)
int nOverflow = 0;
while (nRangeTotal >= RANGE_TOTAL_1[nOverflow + 1]) { nOverflow++; }
// build the value
nValue = nBase + (nOverflow * nPivotValue);
} else {
// decode
uint32 nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT);
// update
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * RANGE_TOTAL_1[nOverflow];
m_RangeCoderInfo.range = m_RangeCoderInfo.range * RANGE_WIDTH_1[nOverflow];
// lookup the symbol (must be a faster way than this)
int nOverflow = 0;
while (nRangeTotal >= RANGE_TOTAL_1[nOverflow + 1])
nOverflow++;
// get the working k
int nTempK;
if (nOverflow == (MODEL_ELEMENTS - 1))
{
nTempK = RangeDecodeFastWithUpdate(5);
nOverflow = 0;
}
else
{
nTempK = (BitArrayState.k < 1) ? 0 : BitArrayState.k - 1;
}
// update
m_RangeCoderInfo.low -= m_RangeCoderInfo.range
* RANGE_TOTAL_1[nOverflow];
m_RangeCoderInfo.range = m_RangeCoderInfo.range
* RANGE_WIDTH_1[nOverflow];
// figure the extra bits on the left and the left value
if (nTempK <= 16 || m_nVersion < 3910)
{
nValue = RangeDecodeFastWithUpdate(nTempK);
}
else
{
int nX1 = RangeDecodeFastWithUpdate(16);
int nX2 = RangeDecodeFastWithUpdate(nTempK - 16);
nValue = nX1 | (nX2 << 16);
}
// get the working k
int nTempK;
if (nOverflow == (MODEL_ELEMENTS - 1)) {
nTempK = RangeDecodeFastWithUpdate(5);
nOverflow = 0;
} else
nTempK = (BitArrayState.k < 1) ? 0 : BitArrayState.k - 1;
// build the value and output it
nValue += (nOverflow << nTempK);
}
// figure the extra bits on the left and the left value
if (nTempK <= 16 || m_nVersion < 3910) {
nValue = RangeDecodeFastWithUpdate(nTempK);
} else {
int nX1 = RangeDecodeFastWithUpdate(16);
int nX2 = RangeDecodeFastWithUpdate(nTempK - 16);
nValue = nX1 | (nX2 << 16);
}
// update nKSum
BitArrayState.nKSum += ((nValue + 1) / 2) - ((BitArrayState.nKSum + 16) >> 5);
// build the value and output it
nValue += (nOverflow << nTempK);
}
// update k
if (BitArrayState.nKSum < K_SUM_MIN_BOUNDARY[BitArrayState.k])
BitArrayState.k--;
else if (BitArrayState.nKSum >= K_SUM_MIN_BOUNDARY[BitArrayState.k + 1])
BitArrayState.k++;
// update nKSum
BitArrayState.nKSum += ((nValue + 1) / 2)
- ((BitArrayState.nKSum + 16) >> 5);
// output the value (converted to signed)
return (nValue & 1) ? (nValue >> 1) + 1 : -(nValue >> 1);
// update k
if (BitArrayState.nKSum < K_SUM_MIN_BOUNDARY[BitArrayState.k])
BitArrayState.k--;
else if (BitArrayState.nKSum >= K_SUM_MIN_BOUNDARY[BitArrayState.k + 1])
BitArrayState.k++;
// output the value (converted to signed)
return (nValue & 1) ? (nValue >> 1) + 1 : -(nValue >> 1);
}
void CUnBitArray::FlushState(UNBIT_ARRAY_STATE & BitArrayState)
void
CUnBitArray::FlushState(UNBIT_ARRAY_STATE& BitArrayState)
{
BitArrayState.k = 10;
BitArrayState.nKSum = (1 << BitArrayState.k) * 16;
BitArrayState.k = 10;
BitArrayState.nKSum = (1 << BitArrayState.k) * 16;
}
void CUnBitArray::FlushBitArray()
void
CUnBitArray::FlushBitArray()
{
AdvanceToByteBoundary();
m_nCurrentBitIndex += 8; // ignore the first byte... (slows compression too much to not output this dummy byte)
m_RangeCoderInfo.buffer = GetC();
m_RangeCoderInfo.low = m_RangeCoderInfo.buffer >> (8 - EXTRA_BITS);
m_RangeCoderInfo.range = (unsigned int) 1 << EXTRA_BITS;
AdvanceToByteBoundary();
m_nCurrentBitIndex += 8;
// ignore the first byte... (slows compression too much to not
// output this dummy byte)
m_RangeCoderInfo.buffer = GetC();
m_RangeCoderInfo.low = m_RangeCoderInfo.buffer >> (8 - EXTRA_BITS);
m_RangeCoderInfo.range = (unsigned int) 1 << EXTRA_BITS;
m_nRefillBitThreshold = (m_nBits - 512);
m_nRefillBitThreshold = (m_nBits - 512);
}
void CUnBitArray::Finalize()
void
CUnBitArray::Finalize()
{
// normalize
while (m_RangeCoderInfo.range <= BOTTOM_VALUE)
{
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.range <<= 8;
}
// normalize
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
m_nCurrentBitIndex += 8;
m_RangeCoderInfo.range <<= 8;
}
// used to back-pedal the last two bytes out
// this should never have been a problem because we've outputted and normalized beforehand
// but stopped doing it as of 3.96 in case it accounted for rare decompression failures
if (m_nVersion <= 3950)
m_nCurrentBitIndex -= 16;
// used to back-pedal the last two bytes out
// this should never have been a problem because we've outputted and normalized beforehand
// but stopped doing it as of 3.96 in case it accounted for rare decompression failures
if (m_nVersion <= 3950)
m_nCurrentBitIndex -= 16;
}
void CUnBitArray::GenerateArrayRange(int * pOutputArray, int nElements)
void
CUnBitArray::GenerateArrayRange(int * pOutputArray, int nElements)
{
UNBIT_ARRAY_STATE BitArrayState;
FlushState(BitArrayState);
FlushBitArray();
UNBIT_ARRAY_STATE BitArrayState;
FlushState(BitArrayState);
FlushBitArray();
for (int z = 0; z < nElements; z++)
{
pOutputArray[z] = DecodeValueRange(BitArrayState);
}
for (int z = 0; z < nElements; z++)
pOutputArray[z] = DecodeValueRange(BitArrayState);
Finalize();
Finalize();
}

62
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.h
View File

@ -1,51 +1,55 @@
#ifndef APE_UNBITARRAY_H
#define APE_UNBITARRAY_H
#include "UnBitArrayBase.h"
class IAPEDecompress;
struct RANGE_CODER_STRUCT_DECOMPRESS
{
unsigned int low; // low end of interval
unsigned int range; // length of interval
unsigned int buffer; // buffer for input/output
unsigned int low; // low end of interval
unsigned int range; // length of interval
unsigned int buffer; // buffer for input/output
};
class CUnBitArray : public CUnBitArrayBase
{
public:
CUnBitArray(CIO* pIO, int nVersion);
~CUnBitArray();
// construction/destruction
CUnBitArray(CIO * pIO, int nVersion);
~CUnBitArray();
uint DecodeValue(DECODE_VALUE_METHOD DecodeMethod,
int nParam1 = 0, int nParam2 = 0);
void GenerateArray(int * pOutputArray, int nElements,
int nBytesRequired = -1);
unsigned int DecodeValue(DECODE_VALUE_METHOD DecodeMethod, int nParam1 = 0, int nParam2 = 0);
void GenerateArray(int * pOutputArray, int nElements, int nBytesRequired = -1);
int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState);
int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState);
void FlushState(UNBIT_ARRAY_STATE & BitArrayState);
void FlushBitArray();
void Finalize();
void FlushState(UNBIT_ARRAY_STATE & BitArrayState);
void FlushBitArray();
void Finalize();
private:
void GenerateArrayRange(int * pOutputArray, int nElements);
void GenerateArrayRange(int * pOutputArray, int nElements);
// data
int m_nFlushCounter;
int m_nFinalizeCounter;
RANGE_CODER_STRUCT_DECOMPRESS m_RangeCoderInfo;
uint32 m_nRefillBitThreshold;
// functions
inline int RangeDecodeFast(int nShift);
inline int RangeDecodeFastWithUpdate(int nShift);
inline unsigned char GetC();
// data
int m_nFlushCounter;
int m_nFinalizeCounter;
RANGE_CODER_STRUCT_DECOMPRESS m_RangeCoderInfo;
uint32 m_nRefillBitThreshold;
// functions
inline int RangeDecodeFast(int nShift);
inline int RangeDecodeFastWithUpdate(int nShift);
inline uchar GetC();
};
#endif // #ifndef APE_UNBITARRAY_H

186
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.cpp
View File

@ -3,113 +3,135 @@
#include "APEInfo.h"
#include "UnBitArray.h"
#undef BACKWARDS_COMPATIBILITY
#ifdef BACKWARDS_COMPATIBILITY
#include "Old/APEDecompressOld.h"
#include "Old/UnBitArrayOld.h"
#include "Old/APEDecompressOld.h"
#include "Old/UnBitArrayOld.h"
#endif
const uint32 POWERS_OF_TWO_MINUS_ONE[33] = {0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535,131071,262143,524287,1048575,2097151,4194303,8388607,16777215,33554431,67108863,134217727,268435455,536870911,1073741823,2147483647,4294967295};
CUnBitArrayBase * CreateUnBitArray(IAPEDecompress * pAPEDecompress, int nVersion)
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 (CUnBitArrayBase * ) new CUnBitArray(GET_IO(pAPEDecompress), nVersion);
else
return (CUnBitArrayBase * ) new CUnBitArrayOld(pAPEDecompress, nVersion);
if (nVersion >= 3900)
return static_cast<CUnBitArrayBase*>
(new CUnBitArray(GET_IO(pAPEDecompress), nVersion));
else
return static_cast<CUnBitArrayBase*>
(new CUnBitArrayOld(pAPEDecompress, nVersion));
#else
return (CUnBitArrayBase * ) new CUnBitArray(GET_IO(pAPEDecompress), nVersion);
return static_cast<CUnBitArrayBase*>
(new CUnBitArray(GET_IO(pAPEDecompress), nVersion));
#endif
}
void CUnBitArrayBase::AdvanceToByteBoundary()
void
CUnBitArrayBase::AdvanceToByteBoundary()
{
int nMod = m_nCurrentBitIndex % 8;
if (nMod != 0) { m_nCurrentBitIndex += 8 - nMod; }
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 their 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);
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)
int
CUnBitArrayBase::FillAndResetBitArray(int nFileLocation, int nNewBitIndex)
{
// reset the bit index
m_nCurrentBitIndex = nNewBitIndex;
// seek if necessary
if (nFileLocation != -1)
{
if (m_pIO->Seek(nFileLocation, FILE_BEGIN) != 0)
return ERROR_IO_READ;
}
// 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;
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()
int
CUnBitArrayBase::FillBitArray()
{
// get the bit array index
uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5;
// move the remaining data to the front
memmove((void *) (m_pBitArray), (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;
// 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;
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;
}

66
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.h
View File

@ -1,59 +1,63 @@
#ifndef APE_UNBITARRAYBASE_H
#define APE_UNBITARRAYBASE_H
class IAPEDecompress;
class CIO;
struct UNBIT_ARRAY_STATE
{
uint32 k;
uint32 nKSum;
uint32 k;
uint32 nKSum;
};
enum DECODE_VALUE_METHOD
{
DECODE_VALUE_METHOD_UNSIGNED_INT,
DECODE_VALUE_METHOD_UNSIGNED_RICE,
DECODE_VALUE_METHOD_X_BITS
DECODE_VALUE_METHOD_UNSIGNED_INT,
DECODE_VALUE_METHOD_UNSIGNED_RICE,
DECODE_VALUE_METHOD_X_BITS
};
class CUnBitArrayBase
{
public:
virtual ~CUnBitArrayBase() {}
// virtual destructor
virtual ~CUnBitArrayBase() {}
virtual int FillBitArray();
virtual int FillAndResetBitArray(int nFileLocation = -1,
int nNewBitIndex = 0);
// functions
virtual int FillBitArray();
virtual int FillAndResetBitArray(int nFileLocation = -1, int nNewBitIndex = 0);
virtual void GenerateArray(int * pOutputArray, int nElements, int nBytesRequired = -1) {}
virtual unsigned int DecodeValue(DECODE_VALUE_METHOD DecodeMethod, int nParam1 = 0, int nParam2 = 0) { return 0; }
virtual void AdvanceToByteBoundary();
virtual void GenerateArray(int * pOutputArray, int nElements,
int nBytesRequired = -1) {}
virtual uint DecodeValue(DECODE_VALUE_METHOD DecodeMethod,
int nParam1 = 0, int nParam2 = 0) { return 0; }
virtual int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState) { return 0; }
virtual void FlushState(UNBIT_ARRAY_STATE & BitArrayState) {}
virtual void FlushBitArray() {}
virtual void Finalize() {}
virtual void AdvanceToByteBoundary();
virtual int DecodeValueRange(UNBIT_ARRAY_STATE& BitArrayState)
{ return 0; }
virtual void FlushState(UNBIT_ARRAY_STATE& BitArrayState) {}
virtual void FlushBitArray() {}
virtual void Finalize() {}
protected:
virtual int CreateHelper(CIO* pIO, int nBytes, int nVersion);
virtual uint32 DecodeValueXBits(uint32 nBits);
virtual int CreateHelper(CIO * pIO, int nBytes, int nVersion);
virtual uint32 DecodeValueXBits(uint32 nBits);
uint32 m_nElements;
uint32 m_nBytes;
uint32 m_nBits;
int m_nVersion;
CIO * m_pIO;
uint32 m_nElements;
uint32 m_nBytes;
uint32 m_nBits;
uint32 m_nCurrentBitIndex;
uint32 * m_pBitArray;
int m_nVersion;
CIO * m_pIO;
uint32 m_nCurrentBitIndex;
uint32 * m_pBitArray;
};
CUnBitArrayBase * CreateUnBitArray(IAPEDecompress * pAPEDecompress, int nVersion);
CUnBitArrayBase* CreateUnBitArray(IAPEDecompress* pAPEDecompress, int nVersion);
#endif // #ifndef APE_UNBITARRAYBASE_H