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); }