CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
const CFX_ByteStringC& type,
const CFX_ByteString& name) {
if (!m_pResources) {
return NULL;
}
if (m_pResources == m_pPageResources) {
CPDF_Dictionary* pList = m_pResources->GetDict(type);
if (!pList) {
return NULL;
}
CPDF_Object* pRes = pList->GetElementValue(name);
return pRes;
}
CPDF_Dictionary* pList = m_pResources->GetDict(type);
if (!pList) {
if (!m_pPageResources) {
return NULL;
}
CPDF_Dictionary* pList = m_pPageResources->GetDict(type);
if (!pList) {
return NULL;
}
CPDF_Object* pRes = pList->GetElementValue(name);
return pRes;
}
CPDF_Object* pRes = pList->GetElementValue(name);
return pRes;
}
CPDF_Object* CPDF_StructElementImpl::GetAttr(FX_BSTR owner, FX_BSTR name, FX_BOOL bInheritable, FX_FLOAT fLevel)
{
if (fLevel > nMaxRecursion) {
return NULL;
}
if (bInheritable) {
CPDF_Object* pAttr = GetAttr(owner, name, FALSE);
if (pAttr) {
return pAttr;
}
if (m_pParent == NULL) {
return NULL;
}
return m_pParent->GetAttr(owner, name, TRUE, fLevel + 1);
}
CPDF_Object* pA = m_pDict->GetElementValue(FX_BSTRC("A"));
if (pA) {
CPDF_Dictionary* pAttrDict = FindAttrDict(pA, owner);
if (pAttrDict) {
CPDF_Object* pAttr = pAttrDict->GetElementValue(name);
if (pAttr) {
return pAttr;
}
}
}
CPDF_Object* pC = m_pDict->GetElementValue(FX_BSTRC("C"));
if (pC == NULL) {
return NULL;
}
CPDF_Dictionary* pClassMap = m_pTree->m_pTreeRoot->GetDict(FX_BSTRC("ClassMap"));
if (pClassMap == NULL) {
return NULL;
}
if (pC->GetType() == PDFOBJ_ARRAY) {
CPDF_Array* pArray = (CPDF_Array*)pC;
for (FX_DWORD i = 0; i < pArray->GetCount(); i ++) {
CFX_ByteString class_name = pArray->GetString(i);
CPDF_Dictionary* pClassDict = pClassMap->GetDict(class_name);
if (pClassDict && pClassDict->GetString(FX_BSTRC("O")) == owner) {
return pClassDict->GetElementValue(name);
}
}
return NULL;
}
CFX_ByteString class_name = pC->GetString();
CPDF_Dictionary* pClassDict = pClassMap->GetDict(class_name);
if (pClassDict && pClassDict->GetString(FX_BSTRC("O")) == owner) {
return pClassDict->GetElementValue(name);
}
return NULL;
}
FX_DWORD CPDF_ActionFields::GetFieldsCount() const {
if (!m_pAction) {
return 0;
}
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict) {
return 0;
}
CFX_ByteString csType = pDict->GetString("S");
CPDF_Object* pFields = NULL;
if (csType == "Hide") {
pFields = pDict->GetElementValue("T");
} else {
pFields = pDict->GetArray("Fields");
}
if (!pFields)
return 0;
if (pFields->IsDictionary())
return 1;
if (pFields->IsString())
return 1;
if (CPDF_Array* pArray = pFields->AsArray())
return pArray->GetCount();
return 0;
}
CPDF_Object* CPDF_ActionFields::GetField(FX_DWORD iIndex) const {
if (!m_pAction) {
return NULL;
}
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict) {
return NULL;
}
CFX_ByteString csType = pDict->GetString("S");
CPDF_Object* pFields = NULL;
if (csType == "Hide") {
pFields = pDict->GetElementValue("T");
} else {
pFields = pDict->GetArray("Fields");
}
if (!pFields) {
return NULL;
}
CPDF_Object* pFindObj = NULL;
if (pFields->IsDictionary() || pFields->IsString()) {
if (iIndex == 0)
pFindObj = pFields;
} else if (CPDF_Array* pArray = pFields->AsArray()) {
pFindObj = pArray->GetElementValue(iIndex);
}
return pFindObj;
}
std::vector<CPDF_Object*> CPDF_ActionFields::GetAllFields() const {
std::vector<CPDF_Object*> fields;
if (!m_pAction)
return fields;
CPDF_Dictionary* pDict = m_pAction->GetDict();
if (!pDict)
return fields;
CFX_ByteString csType = pDict->GetString("S");
CPDF_Object* pFields;
if (csType == "Hide")
pFields = pDict->GetElementValue("T");
else
pFields = pDict->GetArray("Fields");
if (!pFields)
return fields;
if (pFields->IsDictionary() || pFields->IsString()) {
fields.push_back(pFields);
} else if (CPDF_Array* pArray = pFields->AsArray()) {
FX_DWORD iCount = pArray->GetCount();
for (FX_DWORD i = 0; i < iCount; ++i) {
CPDF_Object* pObj = pArray->GetElementValue(i);
if (pObj) {
fields.push_back(pObj);
}
}
}
return fields;
}
CPDF_ShadingPattern::CPDF_ShadingPattern(CPDF_Document* pDoc, CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* parentMatrix) : CPDF_Pattern(parentMatrix)
{
m_PatternType = PATTERN_SHADING;
m_pPatternObj = bShading ? NULL : pPatternObj;
m_pDocument = pDoc;
m_bShadingObj = bShading;
if (!bShading) {
CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
ASSERT(pDict != NULL);
m_Pattern2Form = pDict->GetMatrix(FX_BSTRC("Matrix"));
m_pShadingObj = pDict->GetElementValue(FX_BSTRC("Shading"));
if (parentMatrix) {
m_Pattern2Form.Concat(*parentMatrix);
}
} else {
m_pShadingObj = pPatternObj;
}
m_ShadingType = 0;
m_pCS = NULL;
m_nFuncs = 0;
for (int i = 0; i < 4; i ++) {
m_pFunctions[i] = NULL;
}
m_pCountedCS = NULL;
}
FX_BOOL CPDF_ShadingPattern::Load()
{
if (m_ShadingType != 0) {
return TRUE;
}
CPDF_Dictionary* pShadingDict = m_pShadingObj ? m_pShadingObj->GetDict() : NULL;
if (pShadingDict == NULL) {
return FALSE;
}
if (m_nFuncs) {
for (int i = 0; i < m_nFuncs; i ++)
if (m_pFunctions[i]) {
delete m_pFunctions[i];
}
m_nFuncs = 0;
}
CPDF_Object* pFunc = pShadingDict->GetElementValue(FX_BSTRC("Function"));
if (pFunc) {
if (pFunc->GetType() == PDFOBJ_ARRAY) {
m_nFuncs = ((CPDF_Array*)pFunc)->GetCount();
if (m_nFuncs > 4) {
m_nFuncs = 4;
}
for (int i = 0; i < m_nFuncs; i ++) {
m_pFunctions[i] = CPDF_Function::Load(((CPDF_Array*)pFunc)->GetElementValue(i));
}
} else {
m_pFunctions[0] = CPDF_Function::Load(pFunc);
m_nFuncs = 1;
}
}
CPDF_Object* pCSObj = pShadingDict->GetElementValue(FX_BSTRC("ColorSpace"));
if (pCSObj == NULL) {
return FALSE;
}
CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
m_pCS = pDocPageData->GetColorSpace(pCSObj, NULL);
if (m_pCS) {
m_pCountedCS = pDocPageData->FindColorSpacePtr(m_pCS->GetArray());
}
m_ShadingType = pShadingDict->GetInteger(FX_BSTRC("ShadingType"));
return TRUE;
}
CFX_WideString CFDF_Document::GetWin32Path() const
{
CPDF_Dictionary* pDict = m_pRootDict ? m_pRootDict->GetDict(FX_BSTRC("FDF")) : NULL;
CPDF_Object* pFileSpec = pDict ? pDict->GetElementValue(FX_BSTRC("F")) : NULL;
if (pFileSpec == NULL) {
return CFX_WideString();
}
if (pFileSpec->GetType() == PDFOBJ_STRING) {
return FPDF_FileSpec_GetWin32Path(m_pRootDict->GetDict(FX_BSTRC("FDF")));
}
return FPDF_FileSpec_GetWin32Path(pFileSpec);
}
CPDF_Array* CPDF_NameTree::LookupNamedDest(CPDF_Document* pDoc,
const CFX_ByteStringC& sName) {
CPDF_Object* pValue = LookupValue(sName);
if (!pValue) {
CPDF_Dictionary* pDests = pDoc->GetRoot()->GetDictBy("Dests");
if (!pDests)
return nullptr;
pValue = pDests->GetElementValue(sName);
}
if (!pValue)
return nullptr;
if (CPDF_Array* pArray = pValue->AsArray())
return pArray;
if (CPDF_Dictionary* pDict = pValue->AsDictionary())
return pDict->GetArrayBy("D");
return nullptr;
}
FX_BOOL CPDFSDK_BAAnnot::IsAppearanceValid(CPDF_Annot::AppearanceMode mode) {
CPDF_Dictionary* pAP = m_pAnnot->GetAnnotDict()->GetDictBy("AP");
if (!pAP)
return FALSE;
// Choose the right sub-ap
const FX_CHAR* ap_entry = "N";
if (mode == CPDF_Annot::Down)
ap_entry = "D";
else if (mode == CPDF_Annot::Rollover)
ap_entry = "R";
if (!pAP->KeyExist(ap_entry))
ap_entry = "N";
// Get the AP stream or subdirectory
CPDF_Object* psub = pAP->GetElementValue(ap_entry);
return !!psub;
}
void CPDF_PageContentGenerate::GenerateContent() {
CFX_ByteTextBuf buf;
CPDF_Dictionary* pPageDict = m_pPage->m_pFormDict;
for (int i = 0; i < m_pageObjects.GetSize(); ++i) {
CPDF_PageObject* pPageObj = (CPDF_PageObject*)m_pageObjects[i];
if (!pPageObj || pPageObj->m_Type != PDFPAGE_IMAGE) {
continue;
}
ProcessImage(buf, (CPDF_ImageObject*)pPageObj);
}
CPDF_Object* pContent =
pPageDict ? pPageDict->GetElementValue("Contents") : NULL;
if (pContent != NULL) {
pPageDict->RemoveAt("Contents");
}
CPDF_Stream* pStream = new CPDF_Stream(NULL, 0, NULL);
pStream->SetData(buf.GetBuffer(), buf.GetLength(), FALSE, FALSE);
m_pDocument->AddIndirectObject(pStream);
pPageDict->SetAtReference("Contents", m_pDocument, pStream->GetObjNum());
}
CPDF_Image::~CPDF_Image()
{
if (m_bInline) {
if (m_pStream) {
#ifndef FOXIT_CHROME_BUILD
CPDF_Dictionary* pDict = m_pStream->GetDict();
if (pDict) {
CPDF_Object* pCSObj = pDict->GetElementValue(FX_BSTRC("ColorSpace"));
if (pCSObj && m_pDocument) {
m_pDocument->RemoveColorSpaceFromPageData(pCSObj);
}
}
#endif
m_pStream->Release();
}
if (m_pInlineDict) {
m_pInlineDict->Release();
}
}
}
CPDF_Array* CPDF_NameTree::LookupNamedDest(CPDF_Document* pDoc, FX_BSTR sName)
{
CPDF_Object* pValue = LookupValue(sName);
if (pValue == NULL) {
CPDF_Dictionary* pDests = pDoc->GetRoot()->GetDict(FX_BSTRC("Dests"));
if (pDests == NULL) {
return NULL;
}
pValue = pDests->GetElementValue(sName);
}
if (pValue == NULL) {
return NULL;
}
if (pValue->GetType() == PDFOBJ_ARRAY) {
return (CPDF_Array*)pValue;
}
if (pValue->GetType() == PDFOBJ_DICTIONARY) {
return ((CPDF_Dictionary*)pValue)->GetArray(FX_BSTRC("D"));
}
return NULL;
}
CPDF_Stream* FPDFDOC_GetAnnotAP(CPDF_Dictionary* pAnnotDict, CPDF_Annot::AppearanceMode mode)
{
CPDF_Dictionary* pAP = pAnnotDict->GetDict("AP");
if (pAP == NULL) {
return NULL;
}
const FX_CHAR* ap_entry = "N";
if (mode == CPDF_Annot::Down) {
ap_entry = "D";
} else if (mode == CPDF_Annot::Rollover) {
ap_entry = "R";
}
if (!pAP->KeyExist(ap_entry)) {
ap_entry = "N";
}
CPDF_Object* psub = pAP->GetElementValue(ap_entry);
if (psub == NULL) {
return NULL;
}
CPDF_Stream* pStream = NULL;
if (psub->GetType() == PDFOBJ_STREAM) {
pStream = (CPDF_Stream*)psub;
} else if (psub->GetType() == PDFOBJ_DICTIONARY) {
CFX_ByteString as = pAnnotDict->GetString("AS");
if (as.IsEmpty()) {
CFX_ByteString value = pAnnotDict->GetString(FX_BSTRC("V"));
if (value.IsEmpty()) {
CPDF_Dictionary* pDict = pAnnotDict->GetDict(FX_BSTRC("Parent"));
value = pDict ? pDict->GetString(FX_BSTRC("V")) : CFX_ByteString();
}
if (value.IsEmpty() || !((CPDF_Dictionary*)psub)->KeyExist(value)) {
as = FX_BSTRC("Off");
} else {
as = value;
}
}
pStream = ((CPDF_Dictionary*)psub)->GetStream(as);
}
return pStream;
}
FX_BOOL CPDFSDK_Annot::IsAppearanceValid(CPDF_Annot::AppearanceMode mode)
{
ASSERT(m_pAnnot != NULL);
ASSERT(m_pAnnot->m_pAnnotDict != NULL);
CPDF_Dictionary* pAP = m_pAnnot->m_pAnnotDict->GetDict("AP");
if (pAP == NULL) return FALSE;
// Choose the right sub-ap
const FX_CHAR* ap_entry = "N";
if (mode == CPDF_Annot::Down)
ap_entry = "D";
else if (mode == CPDF_Annot::Rollover)
ap_entry = "R";
if (!pAP->KeyExist(ap_entry))
ap_entry = "N";
// Get the AP stream or subdirectory
CPDF_Object* psub = pAP->GetElementValue(ap_entry);
if (psub == NULL) return FALSE;
return TRUE;
}
void CPDF_PageContentGenerate::TransformContent(CFX_Matrix& matrix) {
CPDF_Dictionary* pDict = m_pPage->m_pFormDict;
CPDF_Object* pContent = pDict ? pDict->GetElementValue("Contents") : NULL;
if (!pContent)
return;
CFX_ByteTextBuf buf;
if (CPDF_Array* pArray = pContent->AsArray()) {
int iCount = pArray->GetCount();
CPDF_StreamAcc** pContentArray = FX_Alloc(CPDF_StreamAcc*, iCount);
int size = 0;
int i = 0;
for (i = 0; i < iCount; ++i) {
pContent = pArray->GetElement(i);
CPDF_Stream* pStream = ToStream(pContent);
if (!pStream)
continue;
CPDF_StreamAcc* pStreamAcc = new CPDF_StreamAcc();
pStreamAcc->LoadAllData(pStream);
pContentArray[i] = pStreamAcc;
size += pContentArray[i]->GetSize() + 1;
}
int pos = 0;
uint8_t* pBuf = FX_Alloc(uint8_t, size);
for (i = 0; i < iCount; ++i) {
FXSYS_memcpy(pBuf + pos, pContentArray[i]->GetData(),
pContentArray[i]->GetSize());
pos += pContentArray[i]->GetSize() + 1;
pBuf[pos - 1] = ' ';
delete pContentArray[i];
}
ProcessForm(buf, pBuf, size, matrix);
FX_Free(pBuf);
FX_Free(pContentArray);
} else if (CPDF_Stream* pStream = pContent->AsStream()) {
FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
CPDF_Stream* pStream = pArray->GetStream(1);
if (pStream == NULL) {
return FALSE;
}
m_pProfile = pDoc->LoadIccProfile(pStream);
if (!m_pProfile) {
return FALSE;
}
m_nComponents = m_pProfile->GetComponents(); //Try using the nComponents from ICC profile
CPDF_Dictionary* pDict = pStream->GetDict();
if (m_pProfile->m_pTransform == NULL) { // No valid ICC profile or using sRGB
CPDF_Object* pAlterCSObj = pDict ? pDict->GetElementValue(FX_BSTRC("Alternate")) : NULL;
if (pAlterCSObj) {
CPDF_ColorSpace* pAlterCS = CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
if (pAlterCS) {
if (m_nComponents == 0) { // NO valid ICC profile
if (pAlterCS->CountComponents() > 0) { // Use Alternative colorspace
m_nComponents = pAlterCS->CountComponents();
m_pAlterCS = pAlterCS;
m_bOwn = TRUE;
}
else { // No valid alternative colorspace
pAlterCS->ReleaseCS();
int32_t nDictComponents = pDict ? pDict->GetInteger(FX_BSTRC("N")) : 0;
if (nDictComponents != 1 && nDictComponents != 3 && nDictComponents != 4) {
return FALSE;
}
m_nComponents = nDictComponents;
}
}
else { // Using sRGB
if (pAlterCS->CountComponents() != m_nComponents) {
pAlterCS->ReleaseCS();
}
else {
m_pAlterCS = pAlterCS;
m_bOwn = TRUE;
}
}
}
}
if (!m_pAlterCS) {
if (m_nComponents == 1) {
m_pAlterCS = GetStockCS(PDFCS_DEVICEGRAY);
}
else if (m_nComponents == 3) {
m_pAlterCS = GetStockCS(PDFCS_DEVICERGB);
}
else if (m_nComponents == 4) {
m_pAlterCS = GetStockCS(PDFCS_DEVICECMYK);
}
}
}
CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
m_pRanges = FX_Alloc2D(FX_FLOAT, m_nComponents, 2);
for (int i = 0; i < m_nComponents * 2; i ++) {
if (pRanges) {
m_pRanges[i] = pRanges->GetNumber(i);
} else if (i % 2) {
m_pRanges[i] = 1.0f;
} else {
m_pRanges[i] = 0;
}
}
return TRUE;
}
void CPDF_StreamContentParser::Handle_BeginImage()
{
FX_FILESIZE savePos = m_pSyntax->GetPos();
CPDF_Dictionary* pDict = CPDF_Dictionary::Create();
while (1) {
CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
if (type == CPDF_StreamParser::Keyword) {
CFX_ByteString bsKeyword(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize());
if (bsKeyword != FX_BSTRC("ID")) {
m_pSyntax->SetPos(savePos);
pDict->Release();
return;
}
}
if (type != CPDF_StreamParser::Name) {
break;
}
CFX_ByteString key((const FX_CHAR*)m_pSyntax->GetWordBuf() + 1, m_pSyntax->GetWordSize() - 1);
CPDF_Object* pObj = m_pSyntax->ReadNextObject();
if (!key.IsEmpty()) {
pDict->SetAt(key, pObj, m_pDocument);
} else if (pObj) {
pObj->Release();
}
}
_PDF_ReplaceAbbr(pDict);
CPDF_Object* pCSObj = NULL;
if (pDict->KeyExist(FX_BSTRC("ColorSpace"))) {
pCSObj = pDict->GetElementValue(FX_BSTRC("ColorSpace"));
if (pCSObj->GetType() == PDFOBJ_NAME) {
CFX_ByteString name = pCSObj->GetString();
if (name != FX_BSTRC("DeviceRGB") && name != FX_BSTRC("DeviceGray") && name != FX_BSTRC("DeviceCMYK")) {
pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
if (pCSObj && !pCSObj->GetObjNum()) {
pCSObj = pCSObj->Clone();
pDict->SetAt(FX_BSTRC("ColorSpace"), pCSObj, m_pDocument);
}
}
}
}
CPDF_Stream* pStream = m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj, m_Options.m_bDecodeInlineImage);
while (1) {
CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
if (type == CPDF_StreamParser::EndOfData) {
break;
}
if (type != CPDF_StreamParser::Keyword) {
continue;
}
if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
m_pSyntax->GetWordBuf()[1] == 'I') {
break;
}
}
if (m_Options.m_bTextOnly) {
if (pStream) {
pStream->Release();
} else {
pDict->Release();
}
return;
}
pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Image"));
CPDF_ImageObject *pImgObj = AddImage(pStream, NULL, TRUE);
if (!pImgObj) {
if (pStream) {
pStream->Release();
} else {
pDict->Release();
}
}
}
CPDF_ColorSpace* CPDF_DocPageData::GetColorSpace(
CPDF_Object* pCSObj,
const CPDF_Dictionary* pResources) {
if (!pCSObj)
return nullptr;
if (pCSObj->IsName()) {
CFX_ByteString name = pCSObj->GetConstString();
CPDF_ColorSpace* pCS = _CSFromName(name);
if (!pCS && pResources) {
CPDF_Dictionary* pList = pResources->GetDictBy("ColorSpace");
if (pList) {
pCSObj = pList->GetElementValue(name);
return GetColorSpace(pCSObj, nullptr);
}
}
if (!pCS || !pResources)
return pCS;
CPDF_Dictionary* pColorSpaces = pResources->GetDictBy("ColorSpace");
if (!pColorSpaces)
return pCS;
CPDF_Object* pDefaultCS = nullptr;
switch (pCS->GetFamily()) {
case PDFCS_DEVICERGB:
pDefaultCS = pColorSpaces->GetElementValue("DefaultRGB");
break;
case PDFCS_DEVICEGRAY:
pDefaultCS = pColorSpaces->GetElementValue("DefaultGray");
break;
case PDFCS_DEVICECMYK:
pDefaultCS = pColorSpaces->GetElementValue("DefaultCMYK");
break;
}
return pDefaultCS ? GetColorSpace(pDefaultCS, nullptr) : pCS;
}
CPDF_Array* pArray = pCSObj->AsArray();
if (!pArray || pArray->GetCount() == 0)
return nullptr;
if (pArray->GetCount() == 1)
return GetColorSpace(pArray->GetElementValue(0), pResources);
CPDF_CountedColorSpace* csData = nullptr;
auto it = m_ColorSpaceMap.find(pCSObj);
if (it != m_ColorSpaceMap.end()) {
csData = it->second;
if (csData->get()) {
return csData->AddRef();
}
}
CPDF_ColorSpace* pCS = CPDF_ColorSpace::Load(m_pPDFDoc, pArray);
if (!pCS)
return nullptr;
if (!csData) {
csData = new CPDF_CountedColorSpace(pCS);
m_ColorSpaceMap[pCSObj] = csData;
} else {
csData->reset(pCS);
}
return csData->AddRef();
}
FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj,
CFX_AffineMatrix* pImage2Device,
const FX_RECT* pClipBox) {
if (FXSYS_fabs(pImage2Device->a) < FXSYS_fabs(pImage2Device->b) * 10 &&
FXSYS_fabs(pImage2Device->d) < FXSYS_fabs(pImage2Device->c) * 10) {
return FALSE;
}
CFX_FloatRect image_rect_f = pImage2Device->GetUnitRect();
FX_RECT image_rect = image_rect_f.GetOutterRect();
m_DestWidth = image_rect.Width();
m_DestHeight = image_rect.Height();
m_bFlipX = pImage2Device->a < 0;
m_bFlipY = pImage2Device->d > 0;
FX_RECT result_rect = *pClipBox;
result_rect.Intersect(image_rect);
if (result_rect.IsEmpty()) {
return FALSE;
}
m_ResultWidth = result_rect.Width();
m_ResultHeight = result_rect.Height();
m_ResultLeft = result_rect.left;
m_ResultTop = result_rect.top;
m_ClipLeft = result_rect.left - image_rect.left;
m_ClipTop = result_rect.top - image_rect.top;
CPDF_Dictionary* pDict = pImageObj->m_pImage->GetDict();
if (pDict->GetInteger(FX_BSTRC("BitsPerComponent")) != 8) {
return FALSE;
}
if (pDict->KeyExist(FX_BSTRC("SMask")) || pDict->KeyExist(FX_BSTRC("Mask"))) {
return FALSE;
}
m_SrcWidth = pDict->GetInteger(FX_BSTRC("Width"));
m_SrcHeight = pDict->GetInteger(FX_BSTRC("Height"));
m_pCS = NULL;
m_Bpp = 3;
CPDF_Object* pCSObj = pDict->GetElementValue(FX_BSTRC("ColorSpace"));
if (pCSObj == NULL) {
return FALSE;
}
m_pCS = CPDF_ColorSpace::Load(pImageObj->m_pImage->GetDocument(), pCSObj);
if (m_pCS == NULL) {
return FALSE;
}
if (!_IsSupported(m_pCS)) {
return FALSE;
}
m_Bpp = m_pCS->CountComponents();
if (m_pCS->sRGB()) {
m_pCS->ReleaseCS();
m_pCS = NULL;
}
CPDF_Stream* pStream = pImageObj->m_pImage->GetStream();
m_StreamAcc.LoadAllData(pStream, FALSE, m_SrcWidth * m_SrcHeight * m_Bpp,
TRUE);
m_pDecoder = NULL;
if (!m_StreamAcc.GetImageDecoder().IsEmpty()) {
if (m_StreamAcc.GetImageDecoder() == FX_BSTRC("DCTDecode")) {
const CPDF_Dictionary* pParam = m_StreamAcc.GetImageParam();
m_pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
m_StreamAcc.GetData(), m_StreamAcc.GetSize(), m_SrcWidth, m_SrcHeight,
m_Bpp,
pParam ? pParam->GetInteger(FX_BSTRC("ColorTransform"), 1) : 1);
} else if (m_StreamAcc.GetImageDecoder() == FX_BSTRC("FlateDecode")) {
m_pDecoder = FPDFAPI_CreateFlateDecoder(
m_StreamAcc.GetData(), m_StreamAcc.GetSize(), m_SrcWidth, m_SrcHeight,
m_Bpp, 8, m_StreamAcc.GetImageParam());
} else {
return FALSE;
}
m_pDecoder->DownScale(m_DestWidth, m_DestHeight);
}
m_pBitmap = new CFX_DIBitmap;
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
m_pBitmap->Create(m_ResultWidth, m_ResultHeight, FXDIB_Rgb32);
#else
m_pBitmap->Create(m_ResultWidth, m_ResultHeight, FXDIB_Rgb);
#endif
m_LineIndex = 0;
return TRUE;
}
CPDF_ColorSpace* CPDF_DocPageData::GetColorSpace(CPDF_Object* pCSObj, CPDF_Dictionary* pResources)
{
if (!pCSObj) {
return NULL;
}
if (pCSObj->GetType() == PDFOBJ_NAME) {
CFX_ByteString name = pCSObj->GetConstString();
CPDF_ColorSpace* pCS = _CSFromName(name);
if (!pCS && pResources) {
CPDF_Dictionary* pList = pResources->GetDict(FX_BSTRC("ColorSpace"));
if (pList) {
pCSObj = pList->GetElementValue(name);
return GetColorSpace(pCSObj, NULL);
}
}
if (pCS == NULL || pResources == NULL) {
return pCS;
}
CPDF_Dictionary* pColorSpaces = pResources->GetDict(FX_BSTRC("ColorSpace"));
if (pColorSpaces == NULL) {
return pCS;
}
CPDF_Object* pDefaultCS = NULL;
switch (pCS->GetFamily()) {
case PDFCS_DEVICERGB:
pDefaultCS = pColorSpaces->GetElementValue(FX_BSTRC("DefaultRGB"));
break;
case PDFCS_DEVICEGRAY:
pDefaultCS = pColorSpaces->GetElementValue(FX_BSTRC("DefaultGray"));
break;
case PDFCS_DEVICECMYK:
pDefaultCS = pColorSpaces->GetElementValue(FX_BSTRC("DefaultCMYK"));
break;
}
if (pDefaultCS == NULL) {
return pCS;
}
return GetColorSpace(pDefaultCS, NULL);
}
if (pCSObj->GetType() != PDFOBJ_ARRAY) {
return NULL;
}
CPDF_Array* pArray = (CPDF_Array*)pCSObj;
if (pArray->GetCount() == 0) {
return NULL;
}
if (pArray->GetCount() == 1) {
return GetColorSpace(pArray->GetElementValue(0), pResources);
}
CPDF_CountedObject<CPDF_ColorSpace*>* csData = NULL;
if (m_ColorSpaceMap.Lookup(pCSObj, csData)) {
if (csData->m_Obj) {
csData->m_nCount++;
return csData->m_Obj;
}
}
FX_BOOL bNew = FALSE;
if (!csData) {
csData = FX_NEW CPDF_CountedObject<CPDF_ColorSpace*>;
if (!csData) {
return NULL;
}
bNew = TRUE;
}
CPDF_ColorSpace* pCS = CPDF_ColorSpace::Load(m_pPDFDoc, pArray);
if (!pCS) {
if (bNew) {
delete csData;
}
return NULL;
}
csData->m_nCount = 2;
csData->m_Obj = pCS;
m_ColorSpaceMap.SetAt(pCSObj, csData);
return pCS;
}