[haiku-commits] r37269 - haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib
- From: wpjvandermeer@xxxxxxxxx
- To: haiku-commits@xxxxxxxxxxxxx
- Date: Sun, 27 Jun 2010 05:02:48 +0200 (CEST)
Author: wim
Date: 2010-06-27 05:02:48 +0200 (Sun, 27 Jun 2010)
New Revision: 37269
Changeset: http://dev.haiku-os.org/changeset/37269/haiku
Modified:
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.cpp
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.h
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.cpp
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.h
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.cpp
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.h
Log:
Compiler warning fixes and code style cleanup. No Functional changes.
Modified: haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.cpp
===================================================================
--- haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.cpp
2010-06-27 01:36:47 UTC (rev 37268)
+++ haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.cpp
2010-06-27 03:02:48 UTC (rev 37269)
@@ -47,7 +47,8 @@
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 @@
}
-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 @@
#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)
{
Modified: haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.h
===================================================================
--- haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.h
2010-06-27 01:36:47 UTC (rev 37268)
+++ haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/Prepare.h
2010-06-27 03:02:48 UTC (rev 37269)
@@ -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
Modified: haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.cpp
===================================================================
--- haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.cpp
2010-06-27 01:36:47 UTC (rev 37268)
+++ haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.cpp
2010-06-27 03:02:48 UTC (rev 37269)
@@ -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();
}
Modified: haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.h
===================================================================
--- haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.h
2010-06-27 01:36:47 UTC (rev 37268)
+++ haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArray.h
2010-06-27 03:02:48 UTC (rev 37269)
@@ -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();
-
- 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);
-
- int DecodeValueRange(UNBIT_ARRAY_STATE & BitArrayState);
+ void GenerateArray(int * pOutputArray, int nElements,
+ int nBytesRequired = -1);
- void FlushState(UNBIT_ARRAY_STATE & BitArrayState);
- void FlushBitArray();
- void Finalize();
-
+ int DecodeValueRange(UNBIT_ARRAY_STATE &
BitArrayState);
+
+ 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
Modified:
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.cpp
===================================================================
--- haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.cpp
2010-06-27 01:36:47 UTC (rev 37268)
+++ haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.cpp
2010-06-27 03:02:48 UTC (rev 37269)
@@ -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)
+
+uint32
+CUnBitArrayBase::DecodeValueXBits(uint32 nBits)
{
- // get more data if necessary
- if ((m_nCurrentBitIndex + nBits) >= m_nBits)
- FillBitArray();
+ // 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);
+ // 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)
+
+int
+CUnBitArrayBase::CreateHelper(CIO * pIO, int nBytes, int nVersion)
{
- // check the parameters
- if ((pIO == NULL) || (nBytes <= 0)) { return ERROR_BAD_PARAMETER; }
+ // 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;
+ // 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;
}
Modified:
haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.h
===================================================================
--- haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.h
2010-06-27 01:36:47 UTC (rev 37268)
+++ haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib/UnBitArrayBase.h
2010-06-27 03:02:48 UTC (rev 37269)
@@ -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;
[... truncated: 23 lines follow ...]
Other related posts:
- » [haiku-commits] r37269 - haiku/trunk/src/add-ons/media/plugins/ape_reader/MAClib - wpjvandermeer
