mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 06:22:44 +08:00
65d72ae4ec
git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@62550 954022d7-b5bf-4e40-9824-e11837661b57
376 lines
8.2 KiB
C++
376 lines
8.2 KiB
C++
#include "Object.h"
|
|
#include "Stream.h"
|
|
#include "JArithmeticDecoder.h"
|
|
|
|
namespace PdfReader
|
|
{
|
|
//-------------------------------------------------------------------------------------------------------------------------------
|
|
// JArithmeticDecoderStates
|
|
//-------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
JArithmeticDecoderStats::JArithmeticDecoderStats(int nContextSize)
|
|
{
|
|
m_nContextSize = nContextSize;
|
|
m_pContextTable = (unsigned char *)MemUtilsMallocArray(m_nContextSize, sizeof(unsigned char));
|
|
Reset();
|
|
}
|
|
|
|
JArithmeticDecoderStats::~JArithmeticDecoderStats()
|
|
{
|
|
MemUtilsFree(m_pContextTable);
|
|
}
|
|
|
|
JArithmeticDecoderStats *JArithmeticDecoderStats::Copy()
|
|
{
|
|
JArithmeticDecoderStats *pStats = new JArithmeticDecoderStats(m_nContextSize);
|
|
memcpy(pStats->m_pContextTable, m_pContextTable, m_nContextSize);
|
|
return pStats;
|
|
}
|
|
|
|
void JArithmeticDecoderStats::Reset()
|
|
{
|
|
memset(m_pContextTable, 0, m_nContextSize);
|
|
}
|
|
|
|
void JArithmeticDecoderStats::CopyFrom(JArithmeticDecoderStats *pStats)
|
|
{
|
|
memcpy(m_pContextTable, pStats->m_pContextTable, m_nContextSize);
|
|
}
|
|
|
|
void JArithmeticDecoderStats::SetEntry(unsigned int unCx, int nIndex, int nMPS)
|
|
{
|
|
m_pContextTable[unCx] = (nIndex << 1) + nMPS;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------------------------------------
|
|
// JArithmeticDecoder
|
|
//-------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
unsigned int JArithmeticDecoder::arrunQeTable[47] =
|
|
{
|
|
0x56010000, 0x34010000, 0x18010000, 0x0AC10000,
|
|
0x05210000, 0x02210000, 0x56010000, 0x54010000,
|
|
0x48010000, 0x38010000, 0x30010000, 0x24010000,
|
|
0x1C010000, 0x16010000, 0x56010000, 0x54010000,
|
|
0x51010000, 0x48010000, 0x38010000, 0x34010000,
|
|
0x30010000, 0x28010000, 0x24010000, 0x22010000,
|
|
0x1C010000, 0x18010000, 0x16010000, 0x14010000,
|
|
0x12010000, 0x11010000, 0x0AC10000, 0x09C10000,
|
|
0x08A10000, 0x05210000, 0x04410000, 0x02A10000,
|
|
0x02210000, 0x01410000, 0x01110000, 0x00850000,
|
|
0x00490000, 0x00250000, 0x00150000, 0x00090000,
|
|
0x00050000, 0x00010000, 0x56010000
|
|
};
|
|
|
|
int JArithmeticDecoder::arrnNMPSTable[47] =
|
|
{
|
|
1, 2, 3, 4, 5, 38, 7, 8, 9, 10, 11, 12, 13, 29, 15, 16,
|
|
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
|
|
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 45, 46
|
|
};
|
|
|
|
int JArithmeticDecoder::arrnNLPSTable[47] =
|
|
{
|
|
1, 6, 9, 12, 29, 33, 6, 14, 14, 14, 17, 18, 20, 21, 14, 14,
|
|
15, 16, 17, 18, 19, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
|
|
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46
|
|
};
|
|
|
|
int JArithmeticDecoder::arrnSwitchTable[47] =
|
|
{
|
|
1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
|
};
|
|
|
|
JArithmeticDecoder::JArithmeticDecoder()
|
|
{
|
|
m_pStream = NULL;
|
|
m_nDataSize = 0;
|
|
m_bLimitStream = false;
|
|
}
|
|
|
|
inline unsigned int JArithmeticDecoder::ReadByte()
|
|
{
|
|
if (m_bLimitStream)
|
|
{
|
|
--m_nDataSize;
|
|
if (m_nDataSize < 0)
|
|
{
|
|
return 0xff;
|
|
}
|
|
}
|
|
return (unsigned int)m_pStream->GetChar() & 0xff;
|
|
}
|
|
|
|
JArithmeticDecoder::~JArithmeticDecoder()
|
|
{
|
|
Cleanup();
|
|
}
|
|
|
|
void JArithmeticDecoder::Start()
|
|
{
|
|
m_unBuffer0 = ReadByte();
|
|
m_unBuffer1 = ReadByte();
|
|
|
|
// INITDEC
|
|
m_unC = (m_unBuffer0 ^ 0xff) << 16;
|
|
ByteIn();
|
|
m_unC <<= 7;
|
|
m_nCT -= 7;
|
|
m_unA = 0x80000000;
|
|
}
|
|
|
|
void JArithmeticDecoder::Restart(int nDatasize)
|
|
{
|
|
int nOldDataSize = m_nDataSize;
|
|
m_nDataSize = nDatasize;
|
|
if (nOldDataSize == -1)
|
|
{
|
|
m_unBuffer1 = ReadByte();
|
|
}
|
|
else if (nOldDataSize <= -2)
|
|
{
|
|
m_unBuffer0 = ReadByte();
|
|
m_unBuffer1 = ReadByte();
|
|
}
|
|
}
|
|
|
|
void JArithmeticDecoder::Cleanup()
|
|
{
|
|
if (m_bLimitStream)
|
|
{
|
|
while (m_nDataSize > 0)
|
|
{
|
|
m_unBuffer0 = m_unBuffer1;
|
|
m_unBuffer1 = ReadByte();
|
|
}
|
|
}
|
|
}
|
|
|
|
int JArithmeticDecoder::DecodeBit(unsigned int unContext, JArithmeticDecoderStats *pStats)
|
|
{
|
|
int nBit = 0;
|
|
|
|
int nICX = pStats->m_pContextTable[unContext] >> 1;
|
|
int nMPSCX = pStats->m_pContextTable[unContext] & 1;
|
|
unsigned int unQe = arrunQeTable[nICX];
|
|
m_unA -= unQe;
|
|
if (m_unC < m_unA)
|
|
{
|
|
if (m_unA & 0x80000000)
|
|
{
|
|
nBit = nMPSCX;
|
|
}
|
|
else
|
|
{
|
|
// MPS_EXCHANGE
|
|
if (m_unA < unQe)
|
|
{
|
|
nBit = 1 - nMPSCX;
|
|
if (arrnSwitchTable[nICX])
|
|
{
|
|
pStats->m_pContextTable[unContext] = (arrnNLPSTable[nICX] << 1) | (1 - nMPSCX);
|
|
}
|
|
else
|
|
{
|
|
pStats->m_pContextTable[unContext] = (arrnNLPSTable[nICX] << 1) | nMPSCX;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nBit = nMPSCX;
|
|
pStats->m_pContextTable[unContext] = (arrnNMPSTable[nICX] << 1) | nMPSCX;
|
|
}
|
|
// RENORMD
|
|
do
|
|
{
|
|
if (m_nCT == 0)
|
|
{
|
|
ByteIn();
|
|
}
|
|
m_unA <<= 1;
|
|
m_unC <<= 1;
|
|
--m_nCT;
|
|
} while (!(m_unA & 0x80000000));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_unC -= m_unA;
|
|
// LPS_EXCHANGE
|
|
if (m_unA < unQe)
|
|
{
|
|
nBit = nMPSCX;
|
|
pStats->m_pContextTable[unContext] = (arrnNMPSTable[nICX] << 1) | nMPSCX;
|
|
}
|
|
else
|
|
{
|
|
nBit = 1 - nMPSCX;
|
|
if (arrnSwitchTable[nICX])
|
|
{
|
|
pStats->m_pContextTable[unContext] = (arrnNLPSTable[nICX] << 1) | (1 - nMPSCX);
|
|
}
|
|
else
|
|
{
|
|
pStats->m_pContextTable[unContext] = (arrnNLPSTable[nICX] << 1) | nMPSCX;
|
|
}
|
|
}
|
|
m_unA = unQe;
|
|
// RENORMD
|
|
do
|
|
{
|
|
if (m_nCT == 0)
|
|
{
|
|
ByteIn();
|
|
}
|
|
m_unA <<= 1;
|
|
m_unC <<= 1;
|
|
--m_nCT;
|
|
} while (!(m_unA & 0x80000000));
|
|
}
|
|
return nBit;
|
|
}
|
|
|
|
int JArithmeticDecoder::DecodeByte(unsigned int unContext, JArithmeticDecoderStats *pStats)
|
|
{
|
|
int nByte = 0;
|
|
for (int nIndex = 0; nIndex < 8; ++nIndex)
|
|
{
|
|
nByte = (nByte << 1) | DecodeBit(unContext, pStats);
|
|
}
|
|
return nByte;
|
|
}
|
|
|
|
bool JArithmeticDecoder::DecodeInt(int *pnValue, JArithmeticDecoderStats *pStats)
|
|
{
|
|
unsigned int unVal = 0;
|
|
m_unPrev = 1;
|
|
int nSign = DecodeIntBit(pStats);
|
|
if (DecodeIntBit(pStats))
|
|
{
|
|
if (DecodeIntBit(pStats))
|
|
{
|
|
if (DecodeIntBit(pStats))
|
|
{
|
|
if (DecodeIntBit(pStats))
|
|
{
|
|
if (DecodeIntBit(pStats))
|
|
{
|
|
unVal = 0;
|
|
for (int nIndex = 0; nIndex < 32; ++nIndex)
|
|
{
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
}
|
|
unVal += 4436;
|
|
}
|
|
else
|
|
{
|
|
unVal = 0;
|
|
for (int nIndex = 0; nIndex < 12; ++nIndex)
|
|
{
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
}
|
|
unVal += 340;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unVal = 0;
|
|
for (int nIndex = 0; nIndex < 8; ++nIndex)
|
|
{
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
}
|
|
unVal += 84;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unVal = 0;
|
|
for (int nIndex = 0; nIndex < 6; ++nIndex)
|
|
{
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
}
|
|
unVal += 20;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unVal = DecodeIntBit(pStats);
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
unVal += 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
unVal = DecodeIntBit(pStats);
|
|
unVal = (unVal << 1) | DecodeIntBit(pStats);
|
|
}
|
|
|
|
if (nSign)
|
|
{
|
|
if (unVal == 0)
|
|
{
|
|
return false;
|
|
}
|
|
*pnValue = -(int)unVal;
|
|
}
|
|
else
|
|
{
|
|
*pnValue = (int)unVal;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int JArithmeticDecoder::DecodeIntBit(JArithmeticDecoderStats *pStats)
|
|
{
|
|
int nBit = DecodeBit(m_unPrev, pStats);
|
|
if (m_unPrev < 0x100)
|
|
{
|
|
m_unPrev = (m_unPrev << 1) | nBit;
|
|
}
|
|
else
|
|
{
|
|
m_unPrev = (((m_unPrev << 1) | nBit) & 0x1ff) | 0x100;
|
|
}
|
|
return nBit;
|
|
}
|
|
|
|
unsigned int JArithmeticDecoder::DecodeIAID(unsigned int unCodeLen, JArithmeticDecoderStats *pStats)
|
|
{
|
|
m_unPrev = 1;
|
|
for (unsigned int unIndex = 0; unIndex < unCodeLen; ++unIndex)
|
|
{
|
|
int nBit = DecodeBit(m_unPrev, pStats);
|
|
m_unPrev = (m_unPrev << 1) | nBit;
|
|
}
|
|
return m_unPrev - (1 << unCodeLen);
|
|
}
|
|
|
|
void JArithmeticDecoder::ByteIn()
|
|
{
|
|
if (m_unBuffer0 == 0xff)
|
|
{
|
|
if (m_unBuffer1 > 0x8f)
|
|
{
|
|
m_nCT = 8;
|
|
}
|
|
else
|
|
{
|
|
m_unBuffer0 = m_unBuffer1;
|
|
m_unBuffer1 = ReadByte();
|
|
m_unC = m_unC + 0xfe00 - (m_unBuffer0 << 9);
|
|
m_nCT = 7;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_unBuffer0 = m_unBuffer1;
|
|
m_unBuffer1 = ReadByte();
|
|
m_unC = m_unC + 0xff00 - (m_unBuffer0 << 8);
|
|
m_nCT = 8;
|
|
}
|
|
}
|
|
} |