i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions 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
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/media/plugins/ape_reader/MAClib/Prepare.cpp
+6 -3
View File
@@ -47,7 +47,8 @@ const uint32 CRC32_TABLE[256] = {0u,1996959894u,3993919788u,2567524794u,
1567103746u,711928724u,3020668471u,3272380065u,1510334235u,755167117u}; 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, const WAVEFORMATEX* pWaveFormatEx, int* pOutputX, int* pOutputY,
unsigned int* pCRC, int* pSpecialCodes, int* pPeakLevel) 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) unsigned char* pOutput, unsigned int* pCRC)
{ {
#define CALCULATE_CRC_BYTE *pCRC = (*pCRC >> 8) ^ CRC32_TABLE[(*pCRC & 0xFF) ^ *pOutput++]; #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 #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, const WAVEFORMATEX* pWaveFormatEx, unsigned char* pRawData,
unsigned int* pCRC, int* pSpecialCodes, int nFileVersion) unsigned int* pCRC, int* pSpecialCodes, int nFileVersion)
{ {
src/add-ons/media/plugins/ape_reader/MAClib/Prepare.h
+2
View File
@@ -1,6 +1,8 @@
#ifndef APE_PREPARE_H #ifndef APE_PREPARE_H
#define APE_PREPARE_H #define APE_PREPARE_H
#include "NoWindows.h"
#define SPECIAL_FRAME_MONO_SILENCE 1 #define SPECIAL_FRAME_MONO_SILENCE 1
#define SPECIAL_FRAME_LEFT_SILENCE 1 #define SPECIAL_FRAME_LEFT_SILENCE 1
#define SPECIAL_FRAME_RIGHT_SILENCE 2 #define SPECIAL_FRAME_RIGHT_SILENCE 2
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.cpp
+136 -89
View File
@@ -6,15 +6,42 @@
#include "BitArray.h" #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_TOTAL_1[65] = {0u,14824u,28224u,39348u,47855u,53994u,58171u,
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}; 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] = {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};
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};
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,};
#define RANGE_OVERFLOW_TOTAL_WIDTH 65536 #define RANGE_OVERFLOW_TOTAL_WIDTH 65536
#define RANGE_OVERFLOW_SHIFT 16 #define RANGE_OVERFLOW_SHIFT 16
@@ -32,9 +59,7 @@ using std::min;
using std::max; using std::max;
#endif #endif
/***********************************************************************************
Construction
***********************************************************************************/
CUnBitArray::CUnBitArray(CIO * pIO, int nVersion) CUnBitArray::CUnBitArray(CIO * pIO, int nVersion)
{ {
CreateHelper(pIO, 16384, nVersion); CreateHelper(pIO, 16384, nVersion);
@@ -42,41 +67,56 @@ CUnBitArray::CUnBitArray(CIO * pIO, int nVersion)
m_nFinalizeCounter = 0; m_nFinalizeCounter = 0;
} }
CUnBitArray::~CUnBitArray() 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) switch (DecodeMethod) {
{
case DECODE_VALUE_METHOD_UNSIGNED_INT: case DECODE_VALUE_METHOD_UNSIGNED_INT:
return DecodeValueXBits(32); 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))); uchar nValue = static_cast<uchar>(m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31)));
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
return nValue; return nValue;
} }
__inline int CUnBitArray::RangeDecodeFast(int nShift)
__inline int
CUnBitArray::RangeDecodeFast(int nShift)
{ {
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
{ m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF); | ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF); m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8; m_RangeCoderInfo.range <<= 8;
} }
@@ -85,13 +125,16 @@ __inline int CUnBitArray::RangeDecodeFast(int nShift)
return m_RangeCoderInfo.low / m_RangeCoderInfo.range; return m_RangeCoderInfo.low / m_RangeCoderInfo.range;
} }
__inline int CUnBitArray::RangeDecodeFastWithUpdate(int nShift) __inline int CUnBitArray::RangeDecodeFastWithUpdate(int nShift)
{ {
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
{ m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF); | ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF); m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8; m_RangeCoderInfo.range <<= 8;
} }
@@ -102,73 +145,77 @@ __inline int CUnBitArray::RangeDecodeFastWithUpdate(int nShift)
return 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 // 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 // this is a little slower than ensuring a huge block to start with,
// but it's safer
if (m_nCurrentBitIndex > m_nRefillBitThreshold) if (m_nCurrentBitIndex > m_nRefillBitThreshold)
{
FillBitArray(); FillBitArray();
}
int nValue = 0; int nValue = 0;
if (m_nVersion >= 3990) if (m_nVersion >= 3990) {
{
// figure the pivot value // figure the pivot value
int nPivotValue = max(BitArrayState.nKSum / 32, 1UL); int nPivotValue = max(BitArrayState.nKSum / 32, 1UL);
// get the overflow // get the overflow
int nOverflow = 0; int nOverflow = 0;
{
// decode // decode
int nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT); uint32 nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT);
// lookup the symbol (must be a faster way than this) // lookup the symbol (must be a faster way than this)
while (nRangeTotal >= RANGE_TOTAL_2[nOverflow + 1]) { nOverflow++; } while (nRangeTotal >= RANGE_TOTAL_2[nOverflow + 1])
nOverflow++;
// update // update
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * RANGE_TOTAL_2[nOverflow]; m_RangeCoderInfo.low -= m_RangeCoderInfo.range
m_RangeCoderInfo.range = m_RangeCoderInfo.range * RANGE_WIDTH_2[nOverflow]; * RANGE_TOTAL_2[nOverflow];
m_RangeCoderInfo.range = m_RangeCoderInfo.range
* RANGE_WIDTH_2[nOverflow];
// get the working k // get the working k
if (nOverflow == (MODEL_ELEMENTS - 1)) if (nOverflow == (MODEL_ELEMENTS - 1)) {
{
nOverflow = RangeDecodeFastWithUpdate(16); nOverflow = RangeDecodeFastWithUpdate(16);
nOverflow <<= 16; nOverflow <<= 16;
nOverflow |= RangeDecodeFastWithUpdate(16); nOverflow |= RangeDecodeFastWithUpdate(16);
} }
}
// get the value // get the value
int nBase = 0; int nBase = 0;
{
int nShift = 0;
if (nPivotValue >= (1 << 16))
{
int nPivotValueBits = 0;
while ((nPivotValue >> nPivotValueBits) > 0) { nPivotValueBits++; }
int nSplitFactor = 1 << (nPivotValueBits - 16);
if (nPivotValue >= (1 << 16)) {
int nPivotValueBits = 0;
while ((nPivotValue >> nPivotValueBits) > 0)
nPivotValueBits++;
int nSplitFactor = 1 << (nPivotValueBits - 16);
int nPivotValueA = (nPivotValue / nSplitFactor) + 1; int nPivotValueA = (nPivotValue / nSplitFactor) + 1;
int nPivotValueB = nSplitFactor; int nPivotValueB = nSplitFactor;
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
{ m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF); | ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF); m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8; m_RangeCoderInfo.range <<= 8;
} }
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueA; m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueA;
int nBaseA = m_RangeCoderInfo.low / m_RangeCoderInfo.range; int nBaseA = m_RangeCoderInfo.low / m_RangeCoderInfo.range;
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseA; m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseA;
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
{ m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF); | ((m_pBitArray[m_nCurrentBitIndex >> 5]
>> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF); m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8; m_RangeCoderInfo.range <<= 8;
} }
m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueB; m_RangeCoderInfo.range = m_RangeCoderInfo.range / nPivotValueB;
@@ -176,14 +223,14 @@ int CUnBitArray::DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState)
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseB; m_RangeCoderInfo.low -= m_RangeCoderInfo.range * nBaseB;
nBase = nBaseA * nSplitFactor + nBaseB; nBase = nBaseA * nSplitFactor + nBaseB;
} } else {
else while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
{ m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8)
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) | ((m_pBitArray[m_nCurrentBitIndex >> 5]
{ >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_RangeCoderInfo.buffer = (m_RangeCoderInfo.buffer << 8) | ((m_pBitArray[m_nCurrentBitIndex >> 5] >> (24 - (m_nCurrentBitIndex & 31))) & 0xFF);
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8) | ((m_RangeCoderInfo.buffer >> 1) & 0xFF); m_RangeCoderInfo.low = (m_RangeCoderInfo.low << 8)
| ((m_RangeCoderInfo.buffer >> 1) & 0xFF);
m_RangeCoderInfo.range <<= 8; m_RangeCoderInfo.range <<= 8;
} }
@@ -194,43 +241,36 @@ int CUnBitArray::DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState)
nBase = nBaseLower; nBase = nBaseLower;
} }
}
// build the value // build the value
nValue = nBase + (nOverflow * nPivotValue); nValue = nBase + (nOverflow * nPivotValue);
} } else {
else
{
// decode // decode
int nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT); uint32 nRangeTotal = RangeDecodeFast(RANGE_OVERFLOW_SHIFT);
// lookup the symbol (must be a faster way than this) // lookup the symbol (must be a faster way than this)
int nOverflow = 0; int nOverflow = 0;
while (nRangeTotal >= RANGE_TOTAL_1[nOverflow + 1]) { nOverflow++; } while (nRangeTotal >= RANGE_TOTAL_1[nOverflow + 1])
nOverflow++;
// update // update
m_RangeCoderInfo.low -= m_RangeCoderInfo.range * RANGE_TOTAL_1[nOverflow]; m_RangeCoderInfo.low -= m_RangeCoderInfo.range
m_RangeCoderInfo.range = m_RangeCoderInfo.range * RANGE_WIDTH_1[nOverflow]; * RANGE_TOTAL_1[nOverflow];
m_RangeCoderInfo.range = m_RangeCoderInfo.range
* RANGE_WIDTH_1[nOverflow];
// get the working k // get the working k
int nTempK; int nTempK;
if (nOverflow == (MODEL_ELEMENTS - 1)) if (nOverflow == (MODEL_ELEMENTS - 1)) {
{
nTempK = RangeDecodeFastWithUpdate(5); nTempK = RangeDecodeFastWithUpdate(5);
nOverflow = 0; nOverflow = 0;
} } else
else
{
nTempK = (BitArrayState.k < 1) ? 0 : BitArrayState.k - 1; nTempK = (BitArrayState.k < 1) ? 0 : BitArrayState.k - 1;
}
// figure the extra bits on the left and the left value // figure the extra bits on the left and the left value
if (nTempK <= 16 || m_nVersion < 3910) if (nTempK <= 16 || m_nVersion < 3910) {
{
nValue = RangeDecodeFastWithUpdate(nTempK); nValue = RangeDecodeFastWithUpdate(nTempK);
} } else {
else
{
int nX1 = RangeDecodeFastWithUpdate(16); int nX1 = RangeDecodeFastWithUpdate(16);
int nX2 = RangeDecodeFastWithUpdate(nTempK - 16); int nX2 = RangeDecodeFastWithUpdate(nTempK - 16);
nValue = nX1 | (nX2 << 16); nValue = nX1 | (nX2 << 16);
@@ -241,7 +281,8 @@ int CUnBitArray::DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState)
} }
// update nKSum // update nKSum
BitArrayState.nKSum += ((nValue + 1) / 2) - ((BitArrayState.nKSum + 16) >> 5); BitArrayState.nKSum += ((nValue + 1) / 2)
- ((BitArrayState.nKSum + 16) >> 5);
// update k // update k
if (BitArrayState.nKSum < K_SUM_MIN_BOUNDARY[BitArrayState.k]) if (BitArrayState.nKSum < K_SUM_MIN_BOUNDARY[BitArrayState.k])
@@ -253,16 +294,21 @@ int CUnBitArray::DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState)
return (nValue & 1) ? (nValue >> 1) + 1 : -(nValue >> 1); 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.k = 10;
BitArrayState.nKSum = (1 << BitArrayState.k) * 16; BitArrayState.nKSum = (1 << BitArrayState.k) * 16;
} }
void CUnBitArray::FlushBitArray() void
CUnBitArray::FlushBitArray()
{ {
AdvanceToByteBoundary(); AdvanceToByteBoundary();
m_nCurrentBitIndex += 8; // ignore the first byte... (slows compression too much to not output this dummy byte) m_nCurrentBitIndex += 8;
// ignore the first byte... (slows compression too much to not
// output this dummy byte)
m_RangeCoderInfo.buffer = GetC(); m_RangeCoderInfo.buffer = GetC();
m_RangeCoderInfo.low = m_RangeCoderInfo.buffer >> (8 - EXTRA_BITS); m_RangeCoderInfo.low = m_RangeCoderInfo.buffer >> (8 - EXTRA_BITS);
m_RangeCoderInfo.range = (unsigned int) 1 << EXTRA_BITS; m_RangeCoderInfo.range = (unsigned int) 1 << EXTRA_BITS;
@@ -270,11 +316,12 @@ void CUnBitArray::FlushBitArray()
m_nRefillBitThreshold = (m_nBits - 512); m_nRefillBitThreshold = (m_nBits - 512);
} }
void CUnBitArray::Finalize()
void
CUnBitArray::Finalize()
{ {
// normalize // normalize
while (m_RangeCoderInfo.range <= BOTTOM_VALUE) while (m_RangeCoderInfo.range <= BOTTOM_VALUE) {
{
m_nCurrentBitIndex += 8; m_nCurrentBitIndex += 8;
m_RangeCoderInfo.range <<= 8; m_RangeCoderInfo.range <<= 8;
} }
@@ -286,16 +333,16 @@ void CUnBitArray::Finalize()
m_nCurrentBitIndex -= 16; m_nCurrentBitIndex -= 16;
} }
void CUnBitArray::GenerateArrayRange(int * pOutputArray, int nElements)
void
CUnBitArray::GenerateArrayRange(int * pOutputArray, int nElements)
{ {
UNBIT_ARRAY_STATE BitArrayState; UNBIT_ARRAY_STATE BitArrayState;
FlushState(BitArrayState); FlushState(BitArrayState);
FlushBitArray(); FlushBitArray();
for (int z = 0; z < nElements; z++) for (int z = 0; z < nElements; z++)
{
pOutputArray[z] = DecodeValueRange(BitArrayState); pOutputArray[z] = DecodeValueRange(BitArrayState);
}
Finalize(); Finalize();
} }
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.h
+11 -7
View File
@@ -1,10 +1,13 @@
#ifndef APE_UNBITARRAY_H #ifndef APE_UNBITARRAY_H
#define APE_UNBITARRAY_H #define APE_UNBITARRAY_H
#include "UnBitArrayBase.h" #include "UnBitArrayBase.h"
class IAPEDecompress; class IAPEDecompress;
struct RANGE_CODER_STRUCT_DECOMPRESS struct RANGE_CODER_STRUCT_DECOMPRESS
{ {
unsigned int low; // low end of interval unsigned int low; // low end of interval
@@ -12,17 +15,18 @@ struct RANGE_CODER_STRUCT_DECOMPRESS
unsigned int buffer; // buffer for input/output unsigned int buffer; // buffer for input/output
}; };
class CUnBitArray : public CUnBitArrayBase class CUnBitArray : public CUnBitArrayBase
{ {
public: public:
CUnBitArray(CIO* pIO, int nVersion);
// construction/destruction
CUnBitArray(CIO * pIO, int nVersion);
~CUnBitArray(); ~CUnBitArray();
unsigned int DecodeValue(DECODE_VALUE_METHOD DecodeMethod, int nParam1 = 0, int nParam2 = 0); uint DecodeValue(DECODE_VALUE_METHOD DecodeMethod,
int nParam1 = 0, int nParam2 = 0);
void GenerateArray(int * pOutputArray, int nElements, int nBytesRequired = -1); void GenerateArray(int * pOutputArray, int nElements,
int nBytesRequired = -1);
int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState); int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState);
@@ -31,7 +35,6 @@ public:
void Finalize(); void Finalize();
private: private:
void GenerateArrayRange(int * pOutputArray, int nElements); void GenerateArrayRange(int * pOutputArray, int nElements);
// data // data
@@ -45,7 +48,8 @@ private:
// functions // functions
inline int RangeDecodeFast(int nShift); inline int RangeDecodeFast(int nShift);
inline int RangeDecodeFastWithUpdate(int nShift); inline int RangeDecodeFastWithUpdate(int nShift);
inline unsigned char GetC(); inline uchar GetC();
}; };
#endif // #ifndef APE_UNBITARRAY_H #endif // #ifndef APE_UNBITARRAY_H
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.cpp
+47 -25
View File
@@ -3,6 +3,7 @@
#include "APEInfo.h" #include "APEInfo.h"
#include "UnBitArray.h" #include "UnBitArray.h"
#undef BACKWARDS_COMPATIBILITY #undef BACKWARDS_COMPATIBILITY
#ifdef BACKWARDS_COMPATIBILITY #ifdef BACKWARDS_COMPATIBILITY
@@ -10,27 +11,41 @@
#include "Old/UnBitArrayOld.h" #include "Old/UnBitArrayOld.h"
#endif #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 #ifdef BACKWARDS_COMPATIBILITY
if (nVersion >= 3900) if (nVersion >= 3900)
return (CUnBitArrayBase * ) new CUnBitArray(GET_IO(pAPEDecompress), nVersion); return static_cast<CUnBitArrayBase*>
(new CUnBitArray(GET_IO(pAPEDecompress), nVersion));
else else
return (CUnBitArrayBase * ) new CUnBitArrayOld(pAPEDecompress, nVersion); return static_cast<CUnBitArrayBase*>
(new CUnBitArrayOld(pAPEDecompress, nVersion));
#else #else
return (CUnBitArrayBase * ) new CUnBitArray(GET_IO(pAPEDecompress), nVersion); return static_cast<CUnBitArrayBase*>
(new CUnBitArray(GET_IO(pAPEDecompress), nVersion));
#endif #endif
} }
void CUnBitArrayBase::AdvanceToByteBoundary()
void
CUnBitArrayBase::AdvanceToByteBoundary()
{ {
int nMod = m_nCurrentBitIndex % 8; int nMod = m_nCurrentBitIndex % 8;
if (nMod != 0) { m_nCurrentBitIndex += 8 - nMod; } if (nMod != 0)
m_nCurrentBitIndex += 8 - nMod;
} }
uint32 CUnBitArrayBase::DecodeValueXBits(uint32 nBits)
uint32
CUnBitArrayBase::DecodeValueXBits(uint32 nBits)
{ {
// get more data if necessary // get more data if necessary
if ((m_nCurrentBitIndex + nBits) >= m_nBits) if ((m_nCurrentBitIndex + nBits) >= m_nBits)
@@ -41,50 +56,54 @@ uint32 CUnBitArrayBase::DecodeValueXBits(uint32 nBits)
uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5; uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5;
m_nCurrentBitIndex += nBits; m_nCurrentBitIndex += nBits;
// if their isn't an overflow to the right value, get the value and exit // if there isn't an overflow to the right value, get the value and exit
if (nLeftBits >= nBits) if (nLeftBits >= nBits)
return (m_pBitArray[nBitArrayIndex] & (POWERS_OF_TWO_MINUS_ONE[nLeftBits])) >> (nLeftBits - nBits); return (m_pBitArray[nBitArrayIndex]
& (POWERS_OF_TWO_MINUS_ONE[nLeftBits])) >> (nLeftBits - nBits);
// must get the "split" value from left and right // must get the "split" value from left and right
int nRightBits = nBits - nLeftBits; int nRightBits = nBits - nLeftBits;
uint32 nLeftValue = ((m_pBitArray[nBitArrayIndex]
uint32 nLeftValue = ((m_pBitArray[nBitArrayIndex] & POWERS_OF_TWO_MINUS_ONE[nLeftBits]) << nRightBits); & POWERS_OF_TWO_MINUS_ONE[nLeftBits]) << nRightBits);
uint32 nRightValue = (m_pBitArray[nBitArrayIndex + 1] >> (32 - nRightBits)); uint32 nRightValue = (m_pBitArray[nBitArrayIndex + 1] >> (32 - nRightBits));
return (nLeftValue | nRightValue); return (nLeftValue | nRightValue);
} }
int CUnBitArrayBase::FillAndResetBitArray(int nFileLocation, int nNewBitIndex)
int
CUnBitArrayBase::FillAndResetBitArray(int nFileLocation, int nNewBitIndex)
{ {
// reset the bit index // reset the bit index
m_nCurrentBitIndex = nNewBitIndex; m_nCurrentBitIndex = nNewBitIndex;
// seek if necessary // seek if necessary
if (nFileLocation != -1) if (nFileLocation != -1 && m_pIO->Seek(nFileLocation, FILE_BEGIN) != 0)
{
if (m_pIO->Seek(nFileLocation, FILE_BEGIN) != 0)
return ERROR_IO_READ; return ERROR_IO_READ;
}
// read the new data into the bit array // read the new data into the bit array
unsigned int nBytesRead = 0; unsigned int nBytesRead = 0;
if (m_pIO->Read(((unsigned char *) m_pBitArray), m_nBytes, &nBytesRead) != 0) if (m_pIO->Read((unsigned char*)m_pBitArray, m_nBytes,
&nBytesRead) != 0)
return ERROR_IO_READ; return ERROR_IO_READ;
return 0; return 0;
} }
int CUnBitArrayBase::FillBitArray()
int
CUnBitArrayBase::FillBitArray()
{ {
// get the bit array index // get the bit array index
uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5; uint32 nBitArrayIndex = m_nCurrentBitIndex >> 5;
// move the remaining data to the front // move the remaining data to the front
memmove((void *) (m_pBitArray), (const void *) (m_pBitArray + nBitArrayIndex), m_nBytes - (nBitArrayIndex * 4)); memmove((void *) (m_pBitArray), static_cast<const void*>(m_pBitArray
+ nBitArrayIndex), m_nBytes - (nBitArrayIndex * 4));
// read the new data // read the new data
int nBytesToRead = nBitArrayIndex * 4; int nBytesToRead = nBitArrayIndex * 4;
unsigned int nBytesRead = 0; unsigned int nBytesRead = 0;
int nRetVal = m_pIO->Read((unsigned char *) (m_pBitArray + m_nElements - nBitArrayIndex), nBytesToRead, &nBytesRead); int nRetVal = m_pIO->Read((unsigned char*)(m_pBitArray + m_nElements
- nBitArrayIndex), nBytesToRead, &nBytesRead);
// adjust the m_Bit pointer // adjust the m_Bit pointer
m_nCurrentBitIndex = m_nCurrentBitIndex & 31; m_nCurrentBitIndex = m_nCurrentBitIndex & 31;
@@ -93,10 +112,13 @@ int CUnBitArrayBase::FillBitArray()
return (nRetVal == 0) ? 0 : ERROR_IO_READ; return (nRetVal == 0) ? 0 : ERROR_IO_READ;
} }
int CUnBitArrayBase::CreateHelper(CIO * pIO, int nBytes, int nVersion)
int
CUnBitArrayBase::CreateHelper(CIO * pIO, int nBytes, int nVersion)
{ {
// check the parameters // check the parameters
if ((pIO == NULL) || (nBytes <= 0)) { return ERROR_BAD_PARAMETER; } if ((pIO == NULL) || (nBytes <= 0))
return ERROR_BAD_PARAMETER;
// save the size // save the size
m_nElements = nBytes / 4; m_nElements = nBytes / 4;
@@ -109,7 +131,7 @@ int CUnBitArrayBase::CreateHelper(CIO * pIO, int nBytes, int nVersion)
m_nCurrentBitIndex = 0; m_nCurrentBitIndex = 0;
// create the bitarray // create the bitarray
m_pBitArray = new uint32 [m_nElements]; m_pBitArray = new uint32[m_nElements];
return (m_pBitArray != NULL) ? 0 : ERROR_INSUFFICIENT_MEMORY; return (m_pBitArray != NULL) ? 0 : ERROR_INSUFFICIENT_MEMORY;
} }
src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.h
+15 -11
View File
@@ -1,9 +1,11 @@
#ifndef APE_UNBITARRAYBASE_H #ifndef APE_UNBITARRAYBASE_H
#define APE_UNBITARRAYBASE_H #define APE_UNBITARRAYBASE_H
class IAPEDecompress; class IAPEDecompress;
class CIO; class CIO;
struct UNBIT_ARRAY_STATE struct UNBIT_ARRAY_STATE
{ {
uint32 k; uint32 k;
@@ -17,30 +19,31 @@ enum DECODE_VALUE_METHOD
DECODE_VALUE_METHOD_X_BITS DECODE_VALUE_METHOD_X_BITS
}; };
class CUnBitArrayBase class CUnBitArrayBase
{ {
public: public:
// virtual destructor
virtual ~CUnBitArrayBase() {} virtual ~CUnBitArrayBase() {}
// functions
virtual int FillBitArray(); virtual int FillBitArray();
virtual int FillAndResetBitArray(int nFileLocation = -1, int nNewBitIndex = 0); virtual int FillAndResetBitArray(int nFileLocation = -1,
int nNewBitIndex = 0);
virtual void GenerateArray(int * pOutputArray, int nElements, int nBytesRequired = -1) {} virtual void GenerateArray(int * pOutputArray, int nElements,
virtual unsigned int DecodeValue(DECODE_VALUE_METHOD DecodeMethod, int nParam1 = 0, int nParam2 = 0) { return 0; } int nBytesRequired = -1) {}
virtual uint DecodeValue(DECODE_VALUE_METHOD DecodeMethod,
int nParam1 = 0, int nParam2 = 0) { return 0; }
virtual void AdvanceToByteBoundary(); virtual void AdvanceToByteBoundary();
virtual int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState) { return 0; } virtual int DecodeValueRange(UNBIT_ARRAY_STATE& BitArrayState)
virtual void FlushState(UNBIT_ARRAY_STATE & BitArrayState) {} { return 0; }
virtual void FlushState(UNBIT_ARRAY_STATE& BitArrayState) {}
virtual void FlushBitArray() {} virtual void FlushBitArray() {}
virtual void Finalize() {} virtual void Finalize() {}
protected: protected:
virtual int CreateHelper(CIO* pIO, int nBytes, int nVersion);
virtual int CreateHelper(CIO * pIO, int nBytes, int nVersion);
virtual uint32 DecodeValueXBits(uint32 nBits); virtual uint32 DecodeValueXBits(uint32 nBits);
uint32 m_nElements; uint32 m_nElements;
@@ -54,6 +57,7 @@ protected:
uint32 * m_pBitArray; uint32 * m_pBitArray;
}; };
CUnBitArrayBase * CreateUnBitArray(IAPEDecompress * pAPEDecompress, int nVersion); CUnBitArrayBase* CreateUnBitArray(IAPEDecompress* pAPEDecompress, int nVersion);
#endif // #ifndef APE_UNBITARRAYBASE_H #endif // #ifndef APE_UNBITARRAYBASE_H