int32_t CFDE_TxtEdtPage::GetDisplayPos(const CFX_RectF& rtClip,
FXTEXT_CHARPOS*& pCharPos,
CFX_RectF* pBBox) const {
pCharPos = FX_Alloc(FXTEXT_CHARPOS, m_nCharCount);
int32_t nCharPosCount = 0;
FDE_TEXTEDITPIECE* pPiece = nullptr;
int32_t nVisualObjCount = m_PieceMassArr.GetSize();
FXTEXT_CHARPOS* pos = pCharPos;
CFX_RectF rtObj;
for (int32_t i = 0; i < nVisualObjCount; i++) {
pPiece = m_PieceMassArr.GetPtrAt(i);
m_pTextSet->GetRect(pPiece, rtObj);
if (!rtClip.IntersectWith(rtObj)) {
continue;
}
int32_t nCount = m_pTextSet->GetDisplayPos(pPiece, pos, FALSE);
nCharPosCount += nCount;
pos += nCount;
}
if ((nCharPosCount * 5) < (m_nCharCount << 2)) {
FXTEXT_CHARPOS* pTemp = FX_Alloc(FXTEXT_CHARPOS, nCharPosCount);
FXSYS_memcpy(pTemp, pCharPos, sizeof(FXTEXT_CHARPOS) * nCharPosCount);
FX_Free(pCharPos);
pCharPos = pTemp;
}
return nCharPosCount;
}
FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj)
{
CPDF_Dictionary* pDict = pObj->GetDict();
if (pDict == NULL) {
return FALSE;
}
CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));
if (m_nOutputs == 0) {
m_nOutputs = 1;
if (pArray0) {
m_nOutputs = pArray0->GetCount();
}
}
CPDF_Array* pArray1 = pDict->GetArray(FX_BSTRC("C1"));
m_pBeginValues = FX_Alloc(FX_FLOAT, m_nOutputs * 2);
m_pEndValues = FX_Alloc(FX_FLOAT, m_nOutputs * 2);
for (int i = 0; i < m_nOutputs; i ++) {
m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;
m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;
}
m_Exponent = pDict->GetFloat(FX_BSTRC("N"));
m_nOrigOutputs = m_nOutputs;
if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
return FALSE;
}
m_nOutputs *= m_nInputs;
return TRUE;
}
void CPDF_TextObject::SetText(int nChars,
FX_DWORD* pCharCodes,
FX_FLOAT* pKernings) {
if (m_nChars > 1) {
FX_Free(m_pCharCodes);
m_pCharCodes = nullptr;
}
FX_Free(m_pCharPos);
m_pCharPos = nullptr;
int nKernings = 0;
int i;
for (i = 0; i < nChars - 1; ++i) {
if (pKernings[i] != 0) {
++nKernings;
}
}
m_nChars = nChars + nKernings;
if (m_nChars > 1) {
m_pCharCodes = FX_Alloc(FX_DWORD, m_nChars);
m_pCharPos = FX_Alloc(FX_FLOAT, m_nChars - 1);
for (int i = 0, index = 0; i < nChars; ++i) {
m_pCharCodes[index++] = pCharCodes[i];
if (pKernings[i] != 0 && i != nChars - 1) {
m_pCharCodes[index] = (FX_DWORD)-1;
m_pCharPos[index - 1] = pKernings[i];
++index;
}
}
} else {
m_pCharCodes = (FX_DWORD*)(uintptr_t)pCharCodes[0];
}
RecalcPositionData();
}
void CPDF_TextObject::SetText(int nChars, FX_DWORD* pCharCodes, FX_FLOAT* pKernings)
{
if (m_nChars > 1 && m_pCharCodes) {
FX_Free(m_pCharCodes);
m_pCharCodes = NULL;
}
if (m_pCharPos) {
FX_Free(m_pCharPos);
m_pCharPos = NULL;
}
int nKernings = 0;
int i;
for (i = 0; i < nChars - 1; i ++)
if (pKernings[i] != 0) {
nKernings ++;
}
m_nChars = nChars + nKernings;
if (m_nChars > 1) {
m_pCharCodes = FX_Alloc(FX_DWORD, m_nChars);
m_pCharPos = FX_Alloc(FX_FLOAT, m_nChars - 1);
int index = 0;
for (int i = 0; i < nChars; i ++) {
m_pCharCodes[index++] = pCharCodes[i];
if (pKernings[i] != 0 && i != nChars - 1) {
m_pCharCodes[index] = (FX_DWORD) - 1;
m_pCharPos[index - 1] = pKernings[i];
index ++;
}
}
} else {
m_pCharCodes = (FX_DWORD*)(FX_UINTPTR)pCharCodes[0];
}
RecalcPositionData();
}
void CPDF_TextObject::CopyData(const CPDF_PageObject* pSrc)
{
const CPDF_TextObject* pSrcObj = (const CPDF_TextObject*)pSrc;
if (m_nChars > 1 && m_pCharCodes) {
FX_Free(m_pCharCodes);
m_pCharCodes = nullptr;
}
if (m_pCharPos) {
FX_Free(m_pCharPos);
m_pCharPos = nullptr;
}
m_nChars = pSrcObj->m_nChars;
if (m_nChars > 1) {
m_pCharCodes = FX_Alloc(FX_DWORD, m_nChars);
m_pCharPos = FX_Alloc(FX_FLOAT, m_nChars - 1);
for (int i = 0; i < m_nChars; ++i) {
m_pCharCodes[i] = pSrcObj->m_pCharCodes[i];
}
for (int i = 0; i < m_nChars - 1; ++i) {
m_pCharPos[i] = pSrcObj->m_pCharPos[i];
}
} else {
m_pCharCodes = pSrcObj->m_pCharCodes;
}
m_PosX = pSrcObj->m_PosX;
m_PosY = pSrcObj->m_PosY;
}
FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj) {
if (pObj->GetType() != PDFOBJ_STREAM) {
return FALSE;
}
CPDF_Stream* pStream = (CPDF_Stream*)pObj;
CPDF_Dictionary* pDict = pStream->GetDict();
CPDF_Array* pSize = pDict->GetArray(FX_BSTRC("Size"));
CPDF_Array* pEncode = pDict->GetArray(FX_BSTRC("Encode"));
CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));
if (m_nBitsPerSample > 32) {
return FALSE;
}
m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
m_pSampleStream = new CPDF_StreamAcc;
m_pSampleStream->LoadAllData(pStream, FALSE);
m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
FX_SAFE_DWORD nTotalSampleBits = 1;
for (int i = 0; i < m_nInputs; i++) {
m_pEncodeInfo[i].sizes = pSize ? pSize->GetInteger(i) : 0;
if (!pSize && i == 0) {
m_pEncodeInfo[i].sizes = pDict->GetInteger(FX_BSTRC("Size"));
}
nTotalSampleBits *= m_pEncodeInfo[i].sizes;
if (pEncode) {
m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);
m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);
} else {
m_pEncodeInfo[i].encode_min = 0;
if (m_pEncodeInfo[i].sizes == 1) {
m_pEncodeInfo[i].encode_max = 1;
} else {
m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
}
}
}
nTotalSampleBits *= m_nBitsPerSample;
nTotalSampleBits *= m_nOutputs;
FX_SAFE_DWORD nTotalSampleBytes = nTotalSampleBits;
nTotalSampleBytes += 7;
nTotalSampleBytes /= 8;
if (!nTotalSampleBytes.IsValid() || nTotalSampleBytes.ValueOrDie() == 0 ||
nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
return FALSE;
}
m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
for (int i = 0; i < m_nOutputs; i++) {
if (pDecode) {
m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);
m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);
} else {
m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];
m_pDecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
}
}
return TRUE;
}
void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
FX_FLOAT origin_x,
FX_FLOAT origin_y,
CPDF_Font* pFont,
FX_FLOAT font_size,
const CFX_AffineMatrix* pMatrix,
const CFX_ByteString& str,
FX_ARGB fill_argb,
FX_ARGB stroke_argb,
const CFX_GraphStateData* pGraphState,
const CPDF_RenderOptions* pOptions) {
int nChars = pFont->CountChar(str, str.GetLength());
if (nChars == 0) {
return;
}
FX_DWORD charcode;
int offset = 0;
FX_DWORD* pCharCodes;
FX_FLOAT* pCharPos;
if (nChars == 1) {
charcode = pFont->GetNextChar(str, str.GetLength(), offset);
pCharCodes = (FX_DWORD*)(uintptr_t)charcode;
pCharPos = NULL;
} else {
pCharCodes = FX_Alloc(FX_DWORD, nChars);
pCharPos = FX_Alloc(FX_FLOAT, nChars - 1);
FX_FLOAT cur_pos = 0;
for (int i = 0; i < nChars; i++) {
pCharCodes[i] = pFont->GetNextChar(str, str.GetLength(), offset);
if (i) {
pCharPos[i - 1] = cur_pos;
}
cur_pos += pFont->GetCharWidthF(pCharCodes[i]) * font_size / 1000;
}
}
CFX_AffineMatrix matrix;
if (pMatrix) {
matrix = *pMatrix;
}
matrix.e = origin_x;
matrix.f = origin_y;
if (pFont->GetFontType() == PDFFONT_TYPE3)
;
else if (stroke_argb == 0) {
DrawNormalText(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
&matrix, fill_argb, pOptions);
} else
DrawTextPath(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
&matrix, NULL, pGraphState, fill_argb, stroke_argb, NULL);
if (nChars > 1) {
FX_Free(pCharCodes);
FX_Free(pCharPos);
}
}
FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj)
{
CPDF_Dictionary* pDict = pObj->GetDict();
if (pDict == NULL) {
return FALSE;
}
CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));
if (pArray == NULL) {
return FALSE;
}
m_nSubs = pArray->GetCount();
if (m_nSubs == 0) {
return FALSE;
}
m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);
m_nOutputs = 0;
int i;
for (i = 0; i < m_nSubs; i ++) {
CPDF_Object* pSub = pArray->GetElementValue(i);
if (pSub == pObj) {
return FALSE;
}
m_pSubFunctions[i] = CPDF_Function::Load(pSub);
if (m_pSubFunctions[i] == NULL) {
return FALSE;
}
if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {
m_nOutputs = m_pSubFunctions[i]->CountOutputs();
}
}
m_pBounds = FX_Alloc(FX_FLOAT, m_nSubs + 1);
m_pBounds[0] = m_pDomains[0];
pArray = pDict->GetArray(FX_BSTRC("Bounds"));
if (pArray == NULL) {
return FALSE;
}
for (i = 0; i < m_nSubs - 1; i ++) {
m_pBounds[i + 1] = pArray->GetFloat(i);
}
m_pBounds[m_nSubs] = m_pDomains[1];
m_pEncode = FX_Alloc(FX_FLOAT, m_nSubs * 2);
pArray = pDict->GetArray(FX_BSTRC("Encode"));
if (pArray == NULL) {
return FALSE;
}
for (i = 0; i < m_nSubs * 2; i ++) {
m_pEncode[i] = pArray->GetFloat(i);
}
return TRUE;
}
CFX_SAXReader::CFX_SAXReader()
: m_File(),
m_pHandler(nullptr),
m_iState(-1),
m_pRoot(nullptr),
m_pCurItem(nullptr),
m_dwItemID(0),
m_iDataSize(256),
m_iNameSize(256),
m_dwParseMode(0),
m_pCommentContext(nullptr) {
m_pszData = FX_Alloc(uint8_t, m_iDataSize);
m_pszName = FX_Alloc(uint8_t, m_iNameSize);
}
void* CPDF_CryptoHandler::CryptStart(uint32_t objnum,
uint32_t gennum,
bool bEncrypt) {
if (m_Cipher == FXCIPHER_NONE) {
return this;
}
if (m_Cipher == FXCIPHER_AES && m_KeyLen == 32) {
AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
pContext->m_bIV = true;
pContext->m_BlockOffset = 0;
CRYPT_AESSetKey(pContext->m_Context, 16, m_EncryptKey, 32, bEncrypt);
if (bEncrypt) {
for (int i = 0; i < 16; i++) {
pContext->m_Block[i] = (uint8_t)rand();
}
CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
}
return pContext;
}
uint8_t key1[48];
PopulateKey(objnum, gennum, key1);
if (m_Cipher == FXCIPHER_AES) {
FXSYS_memcpy(key1 + m_KeyLen + 5, "sAlT", 4);
}
uint8_t realkey[16];
CRYPT_MD5Generate(
key1, m_Cipher == FXCIPHER_AES ? m_KeyLen + 9 : m_KeyLen + 5, realkey);
int realkeylen = m_KeyLen + 5;
if (realkeylen > 16) {
realkeylen = 16;
}
if (m_Cipher == FXCIPHER_AES) {
AESCryptContext* pContext = FX_Alloc(AESCryptContext, 1);
pContext->m_bIV = true;
pContext->m_BlockOffset = 0;
CRYPT_AESSetKey(pContext->m_Context, 16, realkey, 16, bEncrypt);
if (bEncrypt) {
for (int i = 0; i < 16; i++) {
pContext->m_Block[i] = (uint8_t)rand();
}
CRYPT_AESSetIV(pContext->m_Context, pContext->m_Block);
}
return pContext;
}
CRYPT_rc4_context* pContext = FX_Alloc(CRYPT_rc4_context, 1);
CRYPT_ArcFourSetup(pContext, realkey, realkeylen);
return pContext;
}
void CPDF_StandardSecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permissions,
FX_BOOL bEncryptMetadata, FX_LPCBYTE key)
{
FX_BYTE buf[16];
buf[0] = (FX_BYTE)permissions;
buf[1] = (FX_BYTE)(permissions >> 8);
buf[2] = (FX_BYTE)(permissions >> 16);
buf[3] = (FX_BYTE)(permissions >> 24);
buf[4] = 0xff;
buf[5] = 0xff;
buf[6] = 0xff;
buf[7] = 0xff;
buf[8] = bEncryptMetadata ? 'T' : 'F';
buf[9] = 'a';
buf[10] = 'd';
buf[11] = 'b';
FX_BYTE* aes = FX_Alloc(FX_BYTE, 2048);
CRYPT_AESSetKey(aes, 16, key, 32, TRUE);
FX_BYTE iv[16], buf1[16];
FXSYS_memset32(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, buf1, buf, 16);
FX_Free(aes);
pEncryptDict->SetAtString(FX_BSTRC("Perms"), CFX_ByteString(buf1, 16));
}
CPDF_ContentParser::Stage CPDF_ContentParser::PrepareContent() {
m_CurrentOffset = 0;
if (m_StreamArray.empty()) {
m_pData.Reset(m_pSingleStream->GetData());
m_Size = m_pSingleStream->GetSize();
return Stage::kParse;
}
FX_SAFE_UINT32 safeSize = 0;
for (const auto& stream : m_StreamArray) {
m_StreamSegmentOffsets.push_back(safeSize.ValueOrDie());
safeSize += stream->GetSize();
safeSize += 1;
if (!safeSize.IsValid())
return Stage::kComplete;
}
m_Size = safeSize.ValueOrDie();
m_pData.Reset(
std::unique_ptr<uint8_t, FxFreeDeleter>(FX_Alloc(uint8_t, m_Size)));
uint32_t pos = 0;
for (const auto& stream : m_StreamArray) {
memcpy(m_pData.Get() + pos, stream->GetData(), stream->GetSize());
pos += stream->GetSize();
m_pData.Get()[pos++] = ' ';
}
m_StreamArray.clear();
return Stage::kParse;
}
FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf,
FX_DWORD src_size,
int width,
int height,
int nComps,
int bpc) {
m_pSrcBuf = src_buf;
m_SrcSize = src_size;
m_OutputWidth = m_OrigWidth = width;
m_OutputHeight = m_OrigHeight = height;
m_nComps = nComps;
m_bpc = bpc;
m_bColorTransformed = FALSE;
m_DownScale = 1;
// Aligning the pitch to 4 bytes requires an integer overflow check.
FX_SAFE_DWORD pitch = width;
pitch *= nComps;
pitch *= bpc;
pitch += 31;
pitch /= 32;
pitch *= 4;
if (!pitch.IsValid()) {
return FALSE;
}
m_Pitch = pitch.ValueOrDie();
// Overflow should already have been checked before this is called.
m_dwLineBytes = (static_cast<FX_DWORD>(width) * nComps * bpc + 7) / 8;
m_pScanline = FX_Alloc(uint8_t, m_Pitch);
return CheckDestSize();
}
void CPDF_PageRenderCache::CacheOptimization(FX_INT32 dwLimitCacheSize)
{
if (m_nCacheSize <= (FX_DWORD)dwLimitCacheSize) {
return;
}
int nCount = m_ImageCaches.GetCount();
CACHEINFO* pCACHEINFO = (CACHEINFO*)FX_Alloc(FX_BYTE, (sizeof (CACHEINFO)) * nCount);
FX_POSITION pos = m_ImageCaches.GetStartPosition();
int i = 0;
while (pos) {
FX_LPVOID key, value;
m_ImageCaches.GetNextAssoc(pos, key, value);
pCACHEINFO[i].time = ((CPDF_ImageCache*)value)->GetTimeCount();
pCACHEINFO[i++].pStream = ((CPDF_ImageCache*)value)->GetStream();
}
FXSYS_qsort(pCACHEINFO, nCount, sizeof (CACHEINFO), compare);
FX_DWORD nTimeCount = m_nTimeCount;
if (nTimeCount + 1 < nTimeCount) {
for (i = 0; i < nCount; i ++) {
((CPDF_ImageCache*)(m_ImageCaches[pCACHEINFO[i].pStream]))->m_dwTimeCount = i;
}
m_nTimeCount = nCount;
}
i = 0;
while(nCount > 15) {
ClearImageCache(pCACHEINFO[i++].pStream);
nCount--;
}
while (m_nCacheSize > (FX_DWORD)dwLimitCacheSize) {
ClearImageCache(pCACHEINFO[i++].pStream);
}
FX_Free(pCACHEINFO);
}
void CPDF_Stream::SetData(FX_LPCBYTE pData, FX_DWORD size, FX_BOOL bCompressed, FX_BOOL bKeepBuf)
{
if (m_GenNum == (FX_DWORD) - 1) {
if (m_pDataBuf) {
FX_Free(m_pDataBuf);
}
} else {
m_GenNum = (FX_DWORD) - 1;
m_pCryptoHandler = NULL;
}
if (bKeepBuf) {
m_pDataBuf = (FX_LPBYTE)pData;
} else {
m_pDataBuf = FX_Alloc(FX_BYTE, size);
if (pData) {
FXSYS_memcpy32(m_pDataBuf, pData, size);
}
}
m_dwSize = size;
if (m_pDict == NULL) {
m_pDict = new CPDF_Dictionary;
}
m_pDict->SetAtInteger(FX_BSTRC("Length"), size);
if (!bCompressed) {
m_pDict->RemoveAt(FX_BSTRC("Filter"));
m_pDict->RemoveAt(FX_BSTRC("DecodeParms"));
}
}
FX_BOOL FX_File_Copy(FX_BSTR fileNameSrc, FX_BSTR fileNameDst)
{
CFXCRT_FileAccess_CRT src, dst;
if (!src.Open(fileNameSrc, FX_FILEMODE_ReadOnly)) {
return FALSE;
}
FX_FILESIZE size = src.GetSize();
if (!size) {
return FALSE;
}
if (!dst.Open(fileNameDst, FX_FILEMODE_Truncate)) {
return FALSE;
}
FX_FILESIZE num = 0;
FX_LPBYTE pBuffer = FX_Alloc(FX_BYTE, 32768);
if (!pBuffer) {
return FALSE;
}
while (num = src.Read(pBuffer, 32768)) {
if (dst.Write(pBuffer, num) != num) {
break;
}
}
FX_Free(pBuffer);
return TRUE;
}
void CPDF_Stream::SetData(const uint8_t* pData,
uint32_t size,
FX_BOOL bCompressed,
FX_BOOL bKeepBuf) {
if (IsMemoryBased())
FX_Free(m_pDataBuf);
m_GenNum = kMemoryBasedGenNum;
if (bKeepBuf) {
m_pDataBuf = const_cast<uint8_t*>(pData);
} else {
m_pDataBuf = FX_Alloc(uint8_t, size);
if (pData) {
FXSYS_memcpy(m_pDataBuf, pData, size);
}
}
m_dwSize = size;
if (!m_pDict)
m_pDict = new CPDF_Dictionary;
m_pDict->SetAtInteger("Length", size);
if (!bCompressed) {
m_pDict->RemoveAt("Filter");
m_pDict->RemoveAt("DecodeParms");
}
}
void CPDF_PageRenderCache::CacheOptimization(int32_t dwLimitCacheSize) {
if (m_nCacheSize <= (uint32_t)dwLimitCacheSize)
return;
size_t nCount = m_ImageCache.size();
CACHEINFO* pCACHEINFO = FX_Alloc(CACHEINFO, nCount);
size_t i = 0;
for (const auto& it : m_ImageCache) {
pCACHEINFO[i].time = it.second->GetTimeCount();
pCACHEINFO[i++].pStream = it.second->GetStream();
}
FXSYS_qsort(pCACHEINFO, nCount, sizeof(CACHEINFO), compare);
uint32_t nTimeCount = m_nTimeCount;
// Check if time value is about to roll over and reset all entries.
// The comparision is legal because uint32_t is an unsigned type.
if (nTimeCount + 1 < nTimeCount) {
for (i = 0; i < nCount; i++)
m_ImageCache[pCACHEINFO[i].pStream]->m_dwTimeCount = i;
m_nTimeCount = nCount;
}
i = 0;
while (i + 15 < nCount)
ClearImageCacheEntry(pCACHEINFO[i++].pStream);
while (i < nCount && m_nCacheSize > (uint32_t)dwLimitCacheSize)
ClearImageCacheEntry(pCACHEINFO[i++].pStream);
FX_Free(pCACHEINFO);
}
void CFX_BinaryBuf::ExpandBuf(FX_STRSIZE add_size)
{
FX_STRSIZE new_size = add_size + m_DataSize;
if (m_AllocSize >= new_size) {
return;
}
int alloc_step;
if (m_AllocStep == 0) {
alloc_step = m_AllocSize / 4;
if (alloc_step < 128 ) {
alloc_step = 128;
}
} else {
alloc_step = m_AllocStep;
}
new_size = (new_size + alloc_step - 1) / alloc_step * alloc_step;
uint8_t* pNewBuffer = m_pBuffer;
if (pNewBuffer) {
pNewBuffer = FX_Realloc(uint8_t, m_pBuffer, new_size);
} else {
pNewBuffer = FX_Alloc(uint8_t, new_size);
}
m_pBuffer = pNewBuffer;
m_AllocSize = new_size;
}
FX_BOOL CFX_SAXFile::StartFile(IFX_FileRead* pFile,
FX_DWORD dwStart,
FX_DWORD dwLen) {
FXSYS_assert(m_pFile == NULL && pFile != NULL);
FX_DWORD dwSize = pFile->GetSize();
if (dwStart >= dwSize) {
return FALSE;
}
if (dwLen == -1 || dwStart + dwLen > dwSize) {
dwLen = dwSize - dwStart;
}
if (dwLen == 0) {
return FALSE;
}
m_dwBufSize = std::min(dwLen, kSaxFileBufSize);
m_pBuf = FX_Alloc(uint8_t, m_dwBufSize);
if (!pFile->ReadBlock(m_pBuf, dwStart, m_dwBufSize)) {
return FALSE;
}
m_dwStart = dwStart;
m_dwEnd = dwStart + dwLen;
m_dwCur = dwStart;
m_pFile = pFile;
m_dwBufIndex = 0;
return TRUE;
}
FX_BOOL CPSPrinterDriver::Init(HDC hDC, int pslevel, FX_BOOL bCmykOutput) {
m_hDC = hDC;
m_HorzSize = ::GetDeviceCaps(m_hDC, HORZSIZE);
m_VertSize = ::GetDeviceCaps(m_hDC, VERTSIZE);
m_Width = ::GetDeviceCaps(m_hDC, HORZRES);
m_Height = ::GetDeviceCaps(m_hDC, VERTRES);
m_nBitsPerPixel = ::GetDeviceCaps(m_hDC, BITSPIXEL);
m_pPSOutput = new CPSOutput(hDC);
((CPSOutput*)m_pPSOutput)->Init();
m_PSRenderer.Init(m_pPSOutput, pslevel, m_Width, m_Height, bCmykOutput);
m_bCmykOutput = bCmykOutput;
HRGN hRgn = ::CreateRectRgn(0, 0, 1, 1);
int ret = ::GetClipRgn(hDC, hRgn);
if (ret == 1) {
ret = ::GetRegionData(hRgn, 0, NULL);
if (ret) {
RGNDATA* pData = (RGNDATA*)FX_Alloc(uint8_t, ret);
ret = ::GetRegionData(hRgn, ret, pData);
if (ret) {
CFX_PathData path;
path.AllocPointCount(pData->rdh.nCount * 5);
for (FX_DWORD i = 0; i < pData->rdh.nCount; i++) {
RECT* pRect = (RECT*)(pData->Buffer + pData->rdh.nRgnSize * i);
path.AppendRect((FX_FLOAT)pRect->left, (FX_FLOAT)pRect->bottom,
(FX_FLOAT)pRect->right, (FX_FLOAT)pRect->top);
}
m_PSRenderer.SetClip_PathFill(&path, NULL, FXFILL_WINDING);
}
FX_Free(pData);
}
}
::DeleteObject(hRgn);
return TRUE;
}
FX_DWORD _DecodeAllScanlines(ICodec_ScanlineDecoder* pDecoder, FX_LPBYTE& dest_buf, FX_DWORD& dest_size)
{
if (pDecoder == NULL) {
return (FX_DWORD) - 1;
}
int ncomps = pDecoder->CountComps();
int bpc = pDecoder->GetBPC();
int width = pDecoder->GetWidth();
int height = pDecoder->GetHeight();
int pitch = (width * ncomps * bpc + 7) / 8;
if (height == 0 || pitch > (1 << 30) / height) {
delete pDecoder;
return -1;
}
dest_size = pitch * height;
dest_buf = FX_Alloc( FX_BYTE, dest_size);
for (int row = 0; row < height; row ++) {
FX_LPBYTE pLine = pDecoder->GetScanline(row);
if (pLine == NULL) {
break;
}
FXSYS_memcpy32(dest_buf + row * pitch, pLine, pitch);
}
FX_DWORD srcoff = pDecoder->GetSrcOffset();
delete pDecoder;
return srcoff;
}
void CFX_FolderFontInfo::ScanFile(CFX_ByteString& path)
{
FXSYS_FILE* pFile = FXSYS_fopen(path, "rb");
if (pFile == NULL) {
return;
}
FXSYS_fseek(pFile, 0, FXSYS_SEEK_END);
FX_DWORD filesize = FXSYS_ftell(pFile);
FX_BYTE buffer[16];
FXSYS_fseek(pFile, 0, FXSYS_SEEK_SET);
size_t readCnt = FXSYS_fread(buffer, 12, 1, pFile);
if (GET_TT_LONG(buffer) == 0x74746366) {
FX_DWORD nFaces = GET_TT_LONG(buffer + 8);
FX_LPBYTE offsets = FX_Alloc(FX_BYTE, nFaces * 4);
if (!offsets) {
FXSYS_fclose(pFile);
return;
}
readCnt = FXSYS_fread(offsets, nFaces * 4, 1, pFile);
for (FX_DWORD i = 0; i < nFaces; i ++) {
FX_LPBYTE p = offsets + i * 4;
ReportFace(path, pFile, filesize, GET_TT_LONG(p));
}
FX_Free(offsets);
} else {
ReportFace(path, pFile, filesize, 0);
}
FXSYS_fclose(pFile);
}
uint8_t* CFX_BaseMassArrayImp::AddSpaceTo(int32_t index) {
ASSERT(index > -1);
uint8_t* pChunk;
if (index < m_iBlockCount) {
pChunk = (uint8_t*)m_pData->GetAt(index / m_iChunkSize);
} else {
int32_t iMemSize = m_iChunkSize * m_iBlockSize;
while (TRUE) {
if (index < m_iChunkCount * m_iChunkSize) {
pChunk = (uint8_t*)m_pData->GetAt(index / m_iChunkSize);
break;
} else {
pChunk = FX_Alloc(uint8_t, iMemSize);
if (m_iChunkCount < m_pData->GetSize()) {
m_pData->SetAt(m_iChunkCount, pChunk);
} else {
m_pData->Add(pChunk);
}
m_iChunkCount++;
}
}
}
ASSERT(pChunk);
m_iBlockCount = index + 1;
return pChunk + (index % m_iChunkSize) * m_iBlockSize;
}
FXFT_Face CFGAS_FontMgr::LoadFace(IFX_SeekableReadStream* pFontStream,
int32_t iFaceIndex) {
if (!pFontStream)
return nullptr;
CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
pFontMgr->InitFTLibrary();
FXFT_Library library = pFontMgr->GetFTLibrary();
if (!library)
return nullptr;
FXFT_Stream ftStream = FX_Alloc(FXFT_StreamRec, 1);
FXSYS_memset(ftStream, 0, sizeof(FXFT_StreamRec));
ftStream->base = nullptr;
ftStream->descriptor.pointer = pFontStream;
ftStream->pos = 0;
ftStream->size = static_cast<unsigned long>(pFontStream->GetSize());
ftStream->read = _ftStreamRead;
ftStream->close = _ftStreamClose;
FXFT_Open_Args ftArgs;
FXSYS_memset(&ftArgs, 0, sizeof(FXFT_Open_Args));
ftArgs.flags |= FT_OPEN_STREAM;
ftArgs.stream = ftStream;
FXFT_Face pFace = nullptr;
if (FXFT_Open_Face(library, &ftArgs, iFaceIndex, &pFace)) {
FX_Free(ftStream);
return nullptr;
}
FXFT_Set_Pixel_Sizes(pFace, 0, 64);
return pFace;
}
CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpfCallback, FX_LPVOID pUserData) const
{
CPDF_Dictionary *pCloneDict = (CPDF_Dictionary*)m_pDict->Clone(bDirect);
IFX_FileStream *pFS = NULL;
if (lpfCallback) {
pFS = lpfCallback((CPDF_Stream*)this, pUserData);
}
if (!pFS) {
CPDF_StreamAcc acc;
acc.LoadAllData(this, TRUE);
FX_DWORD streamSize = acc.GetSize();
return new CPDF_Stream(acc.DetachData(), streamSize, pCloneDict);
}
CPDF_Stream* pObj = new CPDF_Stream(NULL, 0, NULL);
CPDF_StreamFilter *pSF = GetStreamFilter(TRUE);
if (pSF) {
FX_LPBYTE pBuf = FX_Alloc(FX_BYTE, 4096);
FX_DWORD dwRead;
do {
dwRead = pSF->ReadBlock(pBuf, 4096);
if (dwRead) {
pFS->WriteBlock(pBuf, dwRead);
}
} while (dwRead == 4096);
pFS->Flush();
FX_Free(pBuf);
delete pSF;
}
pObj->InitStream((IFX_FileRead*)pFS, pCloneDict);
return pObj;
}
CFX_BinaryBuf::CFX_BinaryBuf(FX_STRSIZE size)
: m_AllocStep(0)
, m_DataSize(size)
, m_AllocSize(size)
{
m_pBuffer = FX_Alloc(uint8_t, size);
}
FX_BOOL FXFC_LoadFile(FX_LPVOID p, FX_LPCSTR name, FX_LPBYTE& pBuffer, FX_DWORD& size)
{
FXFC_PACKAGE* pPackage = (FXFC_PACKAGE*)p;
FXSYS_fseek(pPackage->m_pFile, pPackage->m_IndexOffset, FXSYS_SEEK_SET);
FX_BYTE buf[128];
for (int i = 0; i < pPackage->m_nFiles; i ++) {
FXSYS_fread(buf, pPackage->m_IndexSize, 1, pPackage->m_pFile);
if (FXSYS_stricmp((FX_LPCSTR)buf, name) == 0) {
FX_DWORD offset = *(FX_DWORD*)&buf[64];
size = *(FX_DWORD*)&buf[68];
pBuffer = FX_Alloc(FX_BYTE, size);
FXSYS_fseek(pPackage->m_pFile, offset, FXSYS_SEEK_SET);
FXSYS_fread(pBuffer, size, 1, pPackage->m_pFile);
if (buf[72]) {
FX_DWORD orig_size;
FX_LPBYTE comp_buf = pBuffer;
CPDF_ModuleMgr::Get()->GetFlateModule()->FlateOrLZWDecode(FALSE, comp_buf, size, FALSE,
0, 0, 0, 0, 0, pBuffer, orig_size);
FX_Free(comp_buf);
size = orig_size;
}
return TRUE;
}
}
return FALSE;
}
void CPDF_SecurityHandler::AES256_SetPerms(CPDF_Dictionary* pEncryptDict,
uint32_t permissions,
FX_BOOL bEncryptMetadata,
const uint8_t* key) {
uint8_t buf[16];
buf[0] = (uint8_t)permissions;
buf[1] = (uint8_t)(permissions >> 8);
buf[2] = (uint8_t)(permissions >> 16);
buf[3] = (uint8_t)(permissions >> 24);
buf[4] = 0xff;
buf[5] = 0xff;
buf[6] = 0xff;
buf[7] = 0xff;
buf[8] = bEncryptMetadata ? 'T' : 'F';
buf[9] = 'a';
buf[10] = 'd';
buf[11] = 'b';
uint8_t* aes = FX_Alloc(uint8_t, 2048);
CRYPT_AESSetKey(aes, 16, key, 32, TRUE);
uint8_t iv[16], buf1[16];
FXSYS_memset(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, buf1, buf, 16);
FX_Free(aes);
pEncryptDict->SetAtString("Perms", CFX_ByteString(buf1, 16));
}
void CBC_QRDecodedBitStreamParser::DecodeByteSegment(
CBC_CommonBitSource* bits,
CFX_ByteString& result,
int32_t count,
CBC_CommonCharacterSetECI* currentCharacterSetECI,
CFX_Int32Array* byteSegments,
int32_t byteModeDecode,
int32_t& e) {
if (count < 0) {
e = BCExceptionNotFound;
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
if ((count << 3) > bits->Available()) {
e = BCExceptionRead;
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
uint8_t* readBytes = FX_Alloc(uint8_t, count);
FXSYS_memset(readBytes, 0x00, count);
for (int32_t i = 0; i < count; i++) {
readBytes[i] = (uint8_t)bits->ReadBits(8, e);
BC_EXCEPTION_CHECK_ReturnVoid(e);
}
CFX_ByteString bs(readBytes, count);
result += bs;
FX_Free(readBytes);
}
