static UInt32 NO_INLINE DecodeBlock2Rand(const UInt32 *tt, UInt32 blockSize, UInt32 OrigPtr, COutBuffer &m_OutStream)
{
CBZip2Crc crc;
UInt32 randIndex = 1;
UInt32 randToGo = kRandNums[0] - 2;
unsigned numReps = 0;
// it's for speed optimization: prefetch & prevByte_init;
UInt32 tPos = tt[tt[OrigPtr] >> 8];
unsigned prevByte = (unsigned)(tPos & 0xFF);
do
{
unsigned b = (unsigned)(tPos & 0xFF);
tPos = tt[tPos >> 8];
{
if (randToGo == 0)
{
b ^= 1;
randToGo = kRandNums[randIndex++];
randIndex &= 0x1FF;
}
randToGo--;
}
if (numReps == kRleModeRepSize)
{
for (; b > 0; b--)
{
crc.UpdateByte(prevByte);
m_OutStream.WriteByte((Byte)prevByte);
}
numReps = 0;
continue;
}
if (b != prevByte)
numReps = 0;
numReps++;
prevByte = b;
crc.UpdateByte(b);
m_OutStream.WriteByte((Byte)b);
}
while (--blockSize != 0);
return crc.GetDigest();
}
COutBuffer* COutBufPacket::buildPacket(unsigned char* pBuf,unsigned int nBufLen,unsigned char nRTPPayloadType
,unsigned int nTimestamp,bool isFirstPacket)
{
if(pBuf == NULL || nBufLen == 0 )
return NULL;
unsigned int nCopySize = 0;
COutBuffer * pOutBuf = getFreeOutBuffer(nBufLen);
if(pOutBuf)
{
m_IsFirstPacket = isFirstPacket;
// Set up the RTP header:
unsigned rtpHdr = 0x80000000; // RTP version 2
rtpHdr |= (nRTPPayloadType<<16);
if(nRTPPayloadType == 0)
{
unsigned short nSeqNo = m_nSeqNo++;
pOutBuf->setSeqNo(nSeqNo);
rtpHdr |= nSeqNo; // sequence number
}
else
{
rtpHdr |= 0;
}
pOutBuf->enqueueWord(rtpHdr);
m_nTimestampPosition = pOutBuf->curPacketSize();
pOutBuf->skipBytes(4);
pOutBuf->enqueueWord(m_nSSRC);
// RTP header:
//m_nSpecialHeaderPosition = pOutBuf->curPacketSize();
//m_nSpecialHeaderSize = specialHeaderSize();
//pOutBuf->skipBytes(m_nSpecialHeaderSize);
//m_nTotalFrameSpecificHeaderSizes = 0;
if(pOutBuf->wouldOverflow(nBufLen))
{
pOutBuf->enqueue(pBuf, nBufLen);
setMarkerBit(pOutBuf);
pOutBuf->insertWord(nTimestamp, m_nTimestampPosition);
return pOutBuf;
}
else
{
PutFreeOutBuffer(pOutBuf);
pOutBuf = NULL;
}
}
return NULL;
}
HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
{
NBitl::CBaseDecoder<CInBuffer> inBuffer;
COutBuffer outBuffer;
if (!inBuffer.Create(kBufferSize))
return E_OUTOFMEMORY;
inBuffer.SetStream(inStream);
inBuffer.Init();
if (!outBuffer.Create(kBufferSize))
return E_OUTOFMEMORY;
outBuffer.SetStream(outStream);
outBuffer.Init();
{
unsigned i;
for (i = 0; i < 257; i++)
_parents[i] = (UInt16)i;
for (; i < kNumItems; i++)
_parents[i] = kNumItems;
for (i = 0; i < kNumItems; i++)
_suffixes[i] = 0;
}
UInt64 prevPos = 0;
unsigned numBits = kNumMinBits;
unsigned head = 257;
int lastSym = -1;
Byte lastChar2 = 0;
for (;;)
{
UInt32 sym = inBuffer.ReadBits(numBits);
if (inBuffer.ExtraBitsWereRead())
break;
if (sym == 256)
{
sym = inBuffer.ReadBits(numBits);
if (sym == 1)
{
if (numBits >= kNumMaxBits)
return S_FALSE;
numBits++;
continue;
}
if (sym != 2)
return S_FALSE;
{
unsigned i;
for (i = 257; i < kNumItems; i++)
_stack[i] = 0;
for (i = 257; i < kNumItems; i++)
{
unsigned par = _parents[i];
if (par != kNumItems)
_stack[par] = 1;
}
for (i = 257; i < kNumItems; i++)
if (_stack[i] == 0)
_parents[i] = kNumItems;
head = 257;
continue;
}
}
bool needPrev = false;
if (head < kNumItems && lastSym >= 0)
{
while (head < kNumItems && _parents[head] != kNumItems)
head++;
if (head < kNumItems)
{
if (head == (unsigned)lastSym)
{
// we need to fix the code for that case
// _parents[head] is not allowed to link to itself
return E_NOTIMPL;
}
needPrev = true;
_parents[head] = (UInt16)lastSym;
_suffixes[head] = (Byte)lastChar2;
head++;
}
}
if (_parents[sym] == kNumItems)
return S_FALSE;
lastSym = sym;
unsigned cur = sym;
unsigned i = 0;
while (cur >= 256)
{
_stack[i++] = _suffixes[cur];
cur = _parents[cur];
}
_stack[i++] = (Byte)cur;
lastChar2 = (Byte)cur;
if (needPrev)
_suffixes[head - 1] = (Byte)cur;
do
outBuffer.WriteByte(_stack[--i]);
while (i);
if (progress)
{
const UInt64 nowPos = outBuffer.GetProcessedSize();
if (nowPos - prevPos >= (1 << 18))
{
prevPos = nowPos;
const UInt64 packSize = inBuffer.GetProcessedSize();
RINOK(progress->SetRatioInfo(&packSize, &nowPos));
}
}
}
return outBuffer.Flush();
}
static UInt32 NO_INLINE DecodeBlock2(const UInt32 *tt, UInt32 blockSize, UInt32 OrigPtr, COutBuffer &m_OutStream)
{
CBZip2Crc crc;
// it's for speed optimization: prefetch & prevByte_init;
UInt32 tPos = tt[tt[OrigPtr] >> 8];
unsigned prevByte = (unsigned)(tPos & 0xFF);
unsigned numReps = 0;
do
{
unsigned b = (unsigned)(tPos & 0xFF);
tPos = tt[tPos >> 8];
if (numReps == kRleModeRepSize)
{
for (; b > 0; b--)
{
crc.UpdateByte(prevByte);
m_OutStream.WriteByte((Byte)prevByte);
}
numReps = 0;
continue;
}
if (b != prevByte)
numReps = 0;
numReps++;
prevByte = b;
crc.UpdateByte(b);
m_OutStream.WriteByte((Byte)b);
/*
prevByte = b;
crc.UpdateByte(b);
m_OutStream.WriteByte((Byte)b);
for (; --blockSize != 0;)
{
b = (unsigned)(tPos & 0xFF);
tPos = tt[tPos >> 8];
crc.UpdateByte(b);
m_OutStream.WriteByte((Byte)b);
if (b != prevByte)
{
prevByte = b;
continue;
}
if (--blockSize == 0)
break;
b = (unsigned)(tPos & 0xFF);
tPos = tt[tPos >> 8];
crc.UpdateByte(b);
m_OutStream.WriteByte((Byte)b);
if (b != prevByte)
{
prevByte = b;
continue;
}
if (--blockSize == 0)
break;
b = (unsigned)(tPos & 0xFF);
tPos = tt[tPos >> 8];
crc.UpdateByte(b);
m_OutStream.WriteByte((Byte)b);
if (b != prevByte)
{
prevByte = b;
continue;
}
--blockSize;
break;
}
if (blockSize == 0)
break;
b = (unsigned)(tPos & 0xFF);
tPos = tt[tPos >> 8];
for (; b > 0; b--)
{
crc.UpdateByte(prevByte);
m_OutStream.WriteByte((Byte)prevByte);
}
*/
}
while (--blockSize != 0);
return crc.GetDigest();
}
STDMETHODIMP CDecoder::CodeReal(ISequentialInStream *inStream,
ISequentialOutStream *outStream, const UInt64 * /* inSize */, const UInt64 * /* outSize */,
ICompressProgressInfo *progress)
{
NStream::NLSBF::CBaseDecoder<CInBuffer> inBuffer;
COutBuffer outBuffer;
if (!inBuffer.Create(kBufferSize))
return E_OUTOFMEMORY;
inBuffer.SetStream(inStream);
inBuffer.Init();
if (!outBuffer.Create(kBufferSize))
return E_OUTOFMEMORY;
outBuffer.SetStream(outStream);
outBuffer.Init();
int maxbits = _properties & kNumBitsMask;
if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
return S_FALSE;
UInt32 numItems = 1 << maxbits;
bool blockMode = ((_properties & kBlockModeMask) != 0);
if (!blockMode)
return E_NOTIMPL;
if (maxbits != _numMaxBits || _parents == 0 || _suffixes == 0 || _stack == 0)
{
if (!Alloc(numItems))
return E_OUTOFMEMORY;
_numMaxBits = maxbits;
}
UInt64 prevPos = 0;
int numBits = kNumMinBits;
UInt32 head = blockMode ? 257 : 256;
bool needPrev = false;
int keepBits = 0;
_parents[256] = 0; // virus protection
_suffixes[256] = 0;
for (;;)
{
if (keepBits < numBits)
keepBits = numBits * 8;
UInt32 symbol = inBuffer.ReadBits(numBits);
if (inBuffer.ExtraBitsWereRead())
break;
keepBits -= numBits;
if (symbol >= head)
return S_FALSE;
if (blockMode && symbol == 256)
{
for (;keepBits > 0; keepBits--)
inBuffer.ReadBits(1);
numBits = kNumMinBits;
head = 257;
needPrev = false;
continue;
}
UInt32 cur = symbol;
int i = 0;
while (cur >= 256)
{
_stack[i++] = _suffixes[cur];
cur = _parents[cur];
}
_stack[i++] = (Byte)cur;
if (needPrev)
{
_suffixes[head - 1] = (Byte)cur;
if (symbol == head - 1)
_stack[0] = (Byte)cur;
}
while (i > 0)
outBuffer.WriteByte((_stack[--i]));
if (head < numItems)
{
needPrev = true;
_parents[head++] = (UInt16)symbol;
if (head > ((UInt32)1 << numBits))
{
if (numBits < maxbits)
{
numBits++;
keepBits = numBits * 8;
}
}
}
else
needPrev = false;
UInt64 nowPos = outBuffer.GetProcessedSize();
if (progress != NULL && nowPos - prevPos > (1 << 18))
{
prevPos = nowPos;
UInt64 packSize = inBuffer.GetProcessedSize();
RINOK(progress->SetRatioInfo(&packSize, &nowPos));
}
}
return outBuffer.Flush();
}
HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
{
NBitl::CBaseDecoder<CInBuffer> inBuffer;
COutBuffer outBuffer;
if (!inBuffer.Create(kBufferSize))
return E_OUTOFMEMORY;
inBuffer.SetStream(inStream);
inBuffer.Init();
if (!outBuffer.Create(kBufferSize))
return E_OUTOFMEMORY;
outBuffer.SetStream(outStream);
outBuffer.Init();
UInt64 prevPos = 0;
int numBits = kNumMinBits;
UInt32 head = 257;
bool needPrev = false;
UInt32 lastSymbol = 0;
int i;
for (i = 0; i < kNumItems; i++)
_parents[i] = 0;
for (i = 0; i < kNumItems; i++)
_suffixes[i] = 0;
for (i = 0; i < 257; i++)
_isFree[i] = false;
for (; i < kNumItems; i++)
_isFree[i] = true;
for (;;)
{
UInt32 symbol = inBuffer.ReadBits(numBits);
if (inBuffer.ExtraBitsWereRead())
break;
if (_isFree[symbol])
return S_FALSE;
if (symbol == 256)
{
UInt32 symbol = inBuffer.ReadBits(numBits);
if (symbol == 1)
{
if (numBits < kNumMaxBits)
numBits++;
}
else if (symbol == 2)
{
if (needPrev)
_isFree[head - 1] = true;
for (i = 257; i < kNumItems; i++)
_isParent[i] = false;
for (i = 257; i < kNumItems; i++)
if (!_isFree[i])
_isParent[_parents[i]] = true;
for (i = 257; i < kNumItems; i++)
if (!_isParent[i])
_isFree[i] = true;
head = 257;
while (head < kNumItems && !_isFree[head])
head++;
if (head < kNumItems)
{
needPrev = true;
_isFree[head] = false;
_parents[head] = (UInt16)lastSymbol;
head++;
}
}
else
return S_FALSE;
continue;
}
UInt32 cur = symbol;
i = 0;
int corectionIndex = -1;
while (cur >= 256)
{
if (cur == head - 1)
corectionIndex = i;
_stack[i++] = _suffixes[cur];
cur = _parents[cur];
}
_stack[i++] = (Byte)cur;
if (needPrev)
{
_suffixes[head - 1] = (Byte)cur;
if (corectionIndex >= 0)
_stack[corectionIndex] = (Byte)cur;
}
while (i > 0)
outBuffer.WriteByte((_stack[--i]));
while (head < kNumItems && !_isFree[head])
head++;
if (head < kNumItems)
{
needPrev = true;
_isFree[head] = false;
_parents[head] = (UInt16)symbol;
head++;
}
else
needPrev = false;
lastSymbol = symbol;
UInt64 nowPos = outBuffer.GetProcessedSize();
if (progress != NULL && nowPos - prevPos > (1 << 18))
{
prevPos = nowPos;
UInt64 packSize = inBuffer.GetProcessedSize();
RINOK(progress->SetRatioInfo(&packSize, &nowPos));
}
}
return outBuffer.Flush();
}
