Home | History | Annotate | Download | only in fpdf_page 
      1 // Copyright 2014 PDFium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
      6 
      7 #include "../../../include/fpdfapi/fpdf_page.h"
      8 #include "../../../include/fpdfapi/fpdf_module.h"
      9 #include "../../../include/fdrm/fx_crypt.h"
     10 #include "../fpdf_font/font_int.h"
     11 #include "pageint.h"
     12 class CPDF_PageModule : public CPDF_PageModuleDef
     13 {
     14 public:
     15     CPDF_PageModule() : m_StockGrayCS(PDFCS_DEVICEGRAY), m_StockRGBCS(PDFCS_DEVICERGB),
     16         m_StockCMYKCS(PDFCS_DEVICECMYK) {}
     17     virtual ~CPDF_PageModule() {}
     18     virtual FX_BOOL		Installed()
     19     {
     20         return TRUE;
     21     }
     22     virtual CPDF_DocPageData*	CreateDocData(CPDF_Document* pDoc)
     23     {
     24         return FX_NEW CPDF_DocPageData(pDoc);
     25     }
     26     virtual void		ReleaseDoc(CPDF_Document* pDoc);
     27     virtual void		ClearDoc(CPDF_Document* pDoc);
     28     virtual CPDF_FontGlobals*	GetFontGlobals()
     29     {
     30         return &m_FontGlobals;
     31     }
     32     virtual void				ClearStockFont(CPDF_Document* pDoc)
     33     {
     34         m_FontGlobals.Clear(pDoc);
     35     }
     36     virtual CPDF_ColorSpace*	GetStockCS(int family);
     37     virtual void		NotifyCJKAvailable();
     38     CPDF_FontGlobals	m_FontGlobals;
     39     CPDF_DeviceCS		m_StockGrayCS;
     40     CPDF_DeviceCS		m_StockRGBCS;
     41     CPDF_DeviceCS		m_StockCMYKCS;
     42     CPDF_PatternCS		m_StockPatternCS;
     43 };
     44 CPDF_ColorSpace* CPDF_PageModule::GetStockCS(int family)
     45 {
     46     if (family == PDFCS_DEVICEGRAY) {
     47         return &m_StockGrayCS;
     48     }
     49     if (family == PDFCS_DEVICERGB) {
     50         return &m_StockRGBCS;
     51     }
     52     if (family == PDFCS_DEVICECMYK) {
     53         return &m_StockCMYKCS;
     54     }
     55     if (family == PDFCS_PATTERN) {
     56         return &m_StockPatternCS;
     57     }
     58     return NULL;
     59 }
     60 void CPDF_ModuleMgr::InitPageModule()
     61 {
     62     if (m_pPageModule) {
     63         delete m_pPageModule;
     64     }
     65     CPDF_PageModule* pPageModule = FX_NEW CPDF_PageModule;
     66     m_pPageModule = pPageModule;
     67 }
     68 void CPDF_PageModule::ReleaseDoc(CPDF_Document* pDoc)
     69 {
     70     delete pDoc->GetPageData();
     71 }
     72 void CPDF_PageModule::ClearDoc(CPDF_Document* pDoc)
     73 {
     74     pDoc->GetPageData()->Clear(FALSE);
     75 }
     76 void CPDF_PageModule::NotifyCJKAvailable()
     77 {
     78     m_FontGlobals.m_CMapManager.ReloadAll();
     79 }
     80 CPDF_Font* CPDF_Document::LoadFont(CPDF_Dictionary* pFontDict)
     81 {
     82     if (!pFontDict) {
     83         return NULL;
     84     }
     85     return GetValidatePageData()->GetFont(pFontDict, FALSE);
     86 }
     87 CPDF_Font* CPDF_Document::FindFont(CPDF_Dictionary* pFontDict)
     88 {
     89     if (!pFontDict) {
     90         return NULL;
     91     }
     92     return GetValidatePageData()->GetFont(pFontDict, TRUE);
     93 }
     94 CPDF_StreamAcc* CPDF_Document::LoadFontFile(CPDF_Stream* pStream)
     95 {
     96     if (pStream == NULL) {
     97         return NULL;
     98     }
     99     return GetValidatePageData()->GetFontFileStreamAcc(pStream);
    100 }
    101 CPDF_ColorSpace* _CSFromName(const CFX_ByteString& name);
    102 CPDF_ColorSpace* CPDF_Document::LoadColorSpace(CPDF_Object* pCSObj, CPDF_Dictionary* pResources)
    103 {
    104     return GetValidatePageData()->GetColorSpace(pCSObj, pResources);
    105 }
    106 CPDF_Pattern* CPDF_Document::LoadPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix)
    107 {
    108     return GetValidatePageData()->GetPattern(pPatternObj, bShading, matrix);
    109 }
    110 CPDF_IccProfile* CPDF_Document::LoadIccProfile(CPDF_Stream* pStream, int nComponents)
    111 {
    112     return GetValidatePageData()->GetIccProfile(pStream, nComponents);
    113 }
    114 CPDF_Image* CPDF_Document::LoadImageF(CPDF_Object* pObj)
    115 {
    116     if (!pObj) {
    117         return NULL;
    118     }
    119     FXSYS_assert(pObj->GetObjNum());
    120     return GetValidatePageData()->GetImage(pObj);
    121 }
    122 void CPDF_Document::RemoveColorSpaceFromPageData(CPDF_Object* pCSObj)
    123 {
    124     if (!pCSObj) {
    125         return;
    126     }
    127     GetPageData()->ReleaseColorSpace(pCSObj);
    128 }
    129 CPDF_DocPageData::CPDF_DocPageData(CPDF_Document *pPDFDoc)
    130     : m_pPDFDoc(pPDFDoc)
    131     , m_FontMap()
    132     , m_ColorSpaceMap()
    133     , m_PatternMap()
    134     , m_ImageMap()
    135     , m_IccProfileMap()
    136     , m_FontFileMap()
    137 {
    138     m_FontMap.InitHashTable(64);
    139     m_ColorSpaceMap.InitHashTable(32);
    140     m_PatternMap.InitHashTable(16);
    141     m_ImageMap.InitHashTable(64);
    142     m_IccProfileMap.InitHashTable(16);
    143     m_FontFileMap.InitHashTable(32);
    144 }
    145 CPDF_DocPageData::~CPDF_DocPageData()
    146 {
    147     Clear(FALSE);
    148     Clear(TRUE);
    149     FX_POSITION pos = NULL;
    150 }
    151 void CPDF_DocPageData::Clear(FX_BOOL bRelease)
    152 {
    153     FX_POSITION pos;
    154     FX_DWORD	nCount;
    155     {
    156         pos = m_PatternMap.GetStartPosition();
    157         while (pos) {
    158             CPDF_Object* ptObj;
    159             CPDF_CountedObject<CPDF_Pattern*>* ptData;
    160             m_PatternMap.GetNextAssoc(pos, ptObj, ptData);
    161             nCount = ptData->m_nCount;
    162             if (bRelease || nCount < 2) {
    163                 delete ptData->m_Obj;
    164                 ptData->m_Obj = NULL;
    165             }
    166         }
    167     }
    168     {
    169         pos = m_FontMap.GetStartPosition();
    170         while (pos) {
    171             CPDF_Dictionary* fontDict;
    172             CPDF_CountedObject<CPDF_Font*>* fontData;
    173             m_FontMap.GetNextAssoc(pos, fontDict, fontData);
    174             nCount = fontData->m_nCount;
    175             if (bRelease || nCount < 2) {
    176                 delete fontData->m_Obj;
    177                 fontData->m_Obj = NULL;
    178             }
    179         }
    180     }
    181     {
    182         pos = m_ImageMap.GetStartPosition();
    183         while (pos) {
    184             FX_DWORD objNum;
    185             CPDF_CountedObject<CPDF_Image*>* imageData;
    186             m_ImageMap.GetNextAssoc(pos, objNum, imageData);
    187             nCount = imageData->m_nCount;
    188             if (bRelease || nCount < 2) {
    189                 delete imageData->m_Obj;
    190                 delete imageData;
    191                 m_ImageMap.RemoveKey(objNum);
    192             }
    193         }
    194     }
    195     {
    196         pos = m_ColorSpaceMap.GetStartPosition();
    197         while (pos) {
    198             CPDF_Object* csKey;
    199             CPDF_CountedObject<CPDF_ColorSpace*>* csData;
    200             m_ColorSpaceMap.GetNextAssoc(pos, csKey, csData);
    201             nCount = csData->m_nCount;
    202             if (bRelease || nCount < 2) {
    203                 csData->m_Obj->ReleaseCS();
    204                 csData->m_Obj = NULL;
    205             }
    206         }
    207     }
    208     {
    209         pos = m_IccProfileMap.GetStartPosition();
    210         while (pos) {
    211             CPDF_Stream* ipKey;
    212             CPDF_CountedObject<CPDF_IccProfile*>* ipData;
    213             m_IccProfileMap.GetNextAssoc(pos, ipKey, ipData);
    214             nCount = ipData->m_nCount;
    215             if (bRelease || nCount < 2) {
    216                 FX_POSITION pos2 = m_HashProfileMap.GetStartPosition();
    217                 while (pos2) {
    218                     CFX_ByteString bsKey;
    219                     CPDF_Stream* pFindStream = NULL;
    220                     m_HashProfileMap.GetNextAssoc(pos2, bsKey, (void*&)pFindStream);
    221                     if (ipKey == pFindStream) {
    222                         m_HashProfileMap.RemoveKey(bsKey);
    223                         break;
    224                     }
    225                 }
    226                 delete ipData->m_Obj;
    227                 delete ipData;
    228                 m_IccProfileMap.RemoveKey(ipKey);
    229             }
    230         }
    231     }
    232     {
    233         pos = m_FontFileMap.GetStartPosition();
    234         while (pos) {
    235             CPDF_Stream* ftKey;
    236             CPDF_CountedObject<CPDF_StreamAcc*>* ftData;
    237             m_FontFileMap.GetNextAssoc(pos, ftKey, ftData);
    238             nCount = ftData->m_nCount;
    239             if (bRelease || nCount < 2) {
    240                 delete ftData->m_Obj;
    241                 delete ftData;
    242                 m_FontFileMap.RemoveKey(ftKey);
    243             }
    244         }
    245     }
    246 }
    247 CPDF_Font* CPDF_DocPageData::GetFont(CPDF_Dictionary* pFontDict, FX_BOOL findOnly)
    248 {
    249     if (!pFontDict) {
    250         return NULL;
    251     }
    252     if (findOnly) {
    253         CPDF_CountedObject<CPDF_Font*>* fontData;
    254         if (m_FontMap.Lookup(pFontDict, fontData)) {
    255             if (!fontData->m_Obj) {
    256                 return NULL;
    257             }
    258             fontData->m_nCount ++;
    259             return fontData->m_Obj;
    260         }
    261         return NULL;
    262     }
    263     CPDF_CountedObject<CPDF_Font*>* fontData = NULL;
    264     if (m_FontMap.Lookup(pFontDict, fontData)) {
    265         if (fontData->m_Obj) {
    266             fontData->m_nCount ++;
    267             return fontData->m_Obj;
    268         }
    269     }
    270     FX_BOOL bNew = FALSE;
    271     if (!fontData) {
    272         fontData = FX_NEW CPDF_CountedObject<CPDF_Font*>;
    273         bNew = TRUE;
    274         if (!fontData) {
    275             return NULL;
    276         }
    277     }
    278     CPDF_Font* pFont = CPDF_Font::CreateFontF(m_pPDFDoc, pFontDict);
    279     if (!pFont) {
    280         if (bNew) {
    281             delete fontData;
    282         }
    283         return NULL;
    284     }
    285     fontData->m_nCount = 2;
    286     fontData->m_Obj = pFont;
    287     m_FontMap.SetAt(pFontDict, fontData);
    288     return pFont;
    289 }
    290 CPDF_Font* CPDF_DocPageData::GetStandardFont(FX_BSTR fontName, CPDF_FontEncoding* pEncoding)
    291 {
    292     if (fontName.IsEmpty()) {
    293         return NULL;
    294     }
    295     FX_POSITION pos = m_FontMap.GetStartPosition();
    296     while (pos) {
    297         CPDF_Dictionary* fontDict;
    298         CPDF_CountedObject<CPDF_Font*>* fontData;
    299         m_FontMap.GetNextAssoc(pos, fontDict, fontData);
    300         CPDF_Font* pFont = fontData->m_Obj;
    301         if (!pFont) {
    302             continue;
    303         }
    304         if (pFont->GetBaseFont() != fontName) {
    305             continue;
    306         }
    307         if (pFont->IsEmbedded()) {
    308             continue;
    309         }
    310         if (pFont->GetFontType() != PDFFONT_TYPE1) {
    311             continue;
    312         }
    313         if (pFont->GetFontDict()->KeyExist(FX_BSTRC("Widths"))) {
    314             continue;
    315         }
    316         CPDF_Type1Font* pT1Font = pFont->GetType1Font();
    317         if (pEncoding && !pT1Font->GetEncoding()->IsIdentical(pEncoding)) {
    318             continue;
    319         }
    320         fontData->m_nCount ++;
    321         return pFont;
    322     }
    323     CPDF_Dictionary* pDict = FX_NEW CPDF_Dictionary;
    324     pDict->SetAtName(FX_BSTRC("Type"), FX_BSTRC("Font"));
    325     pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Type1"));
    326     pDict->SetAtName(FX_BSTRC("BaseFont"), fontName);
    327     if (pEncoding) {
    328         pDict->SetAt(FX_BSTRC("Encoding"), pEncoding->Realize());
    329     }
    330     m_pPDFDoc->AddIndirectObject(pDict);
    331     CPDF_CountedObject<CPDF_Font*>* fontData = FX_NEW CPDF_CountedObject<CPDF_Font*>;
    332     if (!fontData) {
    333         return NULL;
    334     }
    335     CPDF_Font* pFont = CPDF_Font::CreateFontF(m_pPDFDoc, pDict);
    336     if (!pFont) {
    337         delete fontData;
    338         return NULL;
    339     }
    340     fontData->m_nCount = 2;
    341     fontData->m_Obj = pFont;
    342     m_FontMap.SetAt(pDict, fontData);
    343     return pFont;
    344 }
    345 void CPDF_DocPageData::ReleaseFont(CPDF_Dictionary* pFontDict)
    346 {
    347     if (!pFontDict) {
    348         return;
    349     }
    350     CPDF_CountedObject<CPDF_Font*>* fontData;
    351     if (!m_FontMap.Lookup(pFontDict, fontData)) {
    352         return;
    353     }
    354     if (fontData->m_Obj && --fontData->m_nCount == 0) {
    355         delete fontData->m_Obj;
    356         fontData->m_Obj = NULL;
    357     }
    358 }
    359 CPDF_ColorSpace* CPDF_DocPageData::GetColorSpace(CPDF_Object* pCSObj, CPDF_Dictionary* pResources)
    360 {
    361     if (!pCSObj) {
    362         return NULL;
    363     }
    364     if (pCSObj->GetType() == PDFOBJ_NAME) {
    365         CFX_ByteString name = pCSObj->GetConstString();
    366         CPDF_ColorSpace* pCS = _CSFromName(name);
    367         if (!pCS && pResources) {
    368             CPDF_Dictionary* pList = pResources->GetDict(FX_BSTRC("ColorSpace"));
    369             if (pList) {
    370                 pCSObj = pList->GetElementValue(name);
    371                 return GetColorSpace(pCSObj, NULL);
    372             }
    373         }
    374         if (pCS == NULL || pResources == NULL) {
    375             return pCS;
    376         }
    377         CPDF_Dictionary* pColorSpaces = pResources->GetDict(FX_BSTRC("ColorSpace"));
    378         if (pColorSpaces == NULL) {
    379             return pCS;
    380         }
    381         CPDF_Object* pDefaultCS = NULL;
    382         switch (pCS->GetFamily()) {
    383             case PDFCS_DEVICERGB:
    384                 pDefaultCS = pColorSpaces->GetElementValue(FX_BSTRC("DefaultRGB"));
    385                 break;
    386             case PDFCS_DEVICEGRAY:
    387                 pDefaultCS = pColorSpaces->GetElementValue(FX_BSTRC("DefaultGray"));
    388                 break;
    389             case PDFCS_DEVICECMYK:
    390                 pDefaultCS = pColorSpaces->GetElementValue(FX_BSTRC("DefaultCMYK"));
    391                 break;
    392         }
    393         if (pDefaultCS == NULL) {
    394             return pCS;
    395         }
    396         return GetColorSpace(pDefaultCS, NULL);
    397     }
    398     if (pCSObj->GetType() != PDFOBJ_ARRAY) {
    399         return NULL;
    400     }
    401     CPDF_Array* pArray = (CPDF_Array*)pCSObj;
    402     if (pArray->GetCount() == 0) {
    403         return NULL;
    404     }
    405     if (pArray->GetCount() == 1) {
    406         return GetColorSpace(pArray->GetElementValue(0), pResources);
    407     }
    408     CPDF_CountedObject<CPDF_ColorSpace*>* csData = NULL;
    409     if (m_ColorSpaceMap.Lookup(pCSObj, csData)) {
    410         if (csData->m_Obj) {
    411             csData->m_nCount++;
    412             return csData->m_Obj;
    413         }
    414     }
    415     FX_BOOL bNew = FALSE;
    416     if (!csData) {
    417         csData = FX_NEW CPDF_CountedObject<CPDF_ColorSpace*>;
    418         if (!csData) {
    419             return NULL;
    420         }
    421         bNew = TRUE;
    422     }
    423     CPDF_ColorSpace* pCS = CPDF_ColorSpace::Load(m_pPDFDoc, pArray);
    424     if (!pCS) {
    425         if (bNew) {
    426             delete csData;
    427         }
    428         return NULL;
    429     }
    430     csData->m_nCount = 2;
    431     csData->m_Obj = pCS;
    432     m_ColorSpaceMap.SetAt(pCSObj, csData);
    433     return pCS;
    434 }
    435 CPDF_ColorSpace* CPDF_DocPageData::GetCopiedColorSpace(CPDF_Object* pCSObj)
    436 {
    437     if (!pCSObj) {
    438         return NULL;
    439     }
    440     CPDF_CountedObject<CPDF_ColorSpace*>* csData;
    441     if (!m_ColorSpaceMap.Lookup(pCSObj, csData)) {
    442         return NULL;
    443     }
    444     if (!csData->m_Obj) {
    445         return NULL;
    446     }
    447     csData->m_nCount ++;
    448     return csData->m_Obj;
    449 }
    450 void CPDF_DocPageData::ReleaseColorSpace(CPDF_Object* pColorSpace)
    451 {
    452     if (!pColorSpace) {
    453         return;
    454     }
    455     CPDF_CountedObject<CPDF_ColorSpace*>* csData;
    456     if (!m_ColorSpaceMap.Lookup(pColorSpace, csData)) {
    457         return;
    458     }
    459     if (csData->m_Obj && --csData->m_nCount == 0) {
    460         csData->m_Obj->ReleaseCS();
    461         csData->m_Obj = NULL;
    462     }
    463 }
    464 CPDF_Pattern* CPDF_DocPageData::GetPattern(CPDF_Object* pPatternObj, FX_BOOL bShading, const CFX_AffineMatrix* matrix)
    465 {
    466     if (!pPatternObj) {
    467         return NULL;
    468     }
    469     CPDF_CountedObject<CPDF_Pattern*>* ptData = NULL;
    470     if (m_PatternMap.Lookup(pPatternObj, ptData)) {
    471         if (ptData->m_Obj) {
    472             ptData->m_nCount++;
    473             return ptData->m_Obj;
    474         }
    475     }
    476     FX_BOOL bNew = FALSE;
    477     if (!ptData) {
    478         ptData = FX_NEW CPDF_CountedObject<CPDF_Pattern*>;
    479         bNew = TRUE;
    480         if (!ptData) {
    481             return NULL;
    482         }
    483     }
    484     CPDF_Pattern* pPattern = NULL;
    485     if (bShading) {
    486         pPattern = FX_NEW CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, bShading, matrix);
    487     } else {
    488         CPDF_Dictionary* pDict = pPatternObj->GetDict();
    489         if (pDict) {
    490             int type = pDict->GetInteger(FX_BSTRC("PatternType"));
    491             if (type == 1) {
    492                 pPattern = FX_NEW CPDF_TilingPattern(m_pPDFDoc, pPatternObj, matrix);
    493             } else if (type == 2) {
    494                 pPattern = FX_NEW CPDF_ShadingPattern(m_pPDFDoc, pPatternObj, FALSE, matrix);
    495             }
    496         }
    497     }
    498     if (!pPattern) {
    499         if (bNew) {
    500             delete ptData;
    501         }
    502         return NULL;
    503     }
    504     ptData->m_nCount = 2;
    505     ptData->m_Obj = pPattern;
    506     m_PatternMap.SetAt(pPatternObj, ptData);
    507     return pPattern;
    508 }
    509 void CPDF_DocPageData::ReleasePattern(CPDF_Object* pPatternObj)
    510 {
    511     if (!pPatternObj) {
    512         return;
    513     }
    514     CPDF_CountedObject<CPDF_Pattern*>* ptData;
    515     if (!m_PatternMap.Lookup(pPatternObj, ptData)) {
    516         return;
    517     }
    518     if (ptData->m_Obj && --ptData->m_nCount == 0) {
    519         delete ptData->m_Obj;
    520         ptData->m_Obj = NULL;
    521     }
    522 }
    523 CPDF_Image* CPDF_DocPageData::GetImage(CPDF_Object* pImageStream)
    524 {
    525     if (!pImageStream) {
    526         return NULL;
    527     }
    528     FX_DWORD dwImageObjNum = pImageStream->GetObjNum();
    529     CPDF_CountedObject<CPDF_Image*>* imageData;
    530     if (m_ImageMap.Lookup(dwImageObjNum, imageData)) {
    531         imageData->m_nCount ++;
    532         return imageData->m_Obj;
    533     }
    534     imageData = FX_NEW CPDF_CountedObject<CPDF_Image*>;
    535     if (!imageData) {
    536         return NULL;
    537     }
    538     CPDF_Image* pImage = FX_NEW CPDF_Image(m_pPDFDoc);
    539     if (!pImage) {
    540         delete imageData;
    541         return NULL;
    542     }
    543     pImage->LoadImageF((CPDF_Stream*)pImageStream, FALSE);
    544     imageData->m_nCount = 2;
    545     imageData->m_Obj = pImage;
    546     m_ImageMap.SetAt(dwImageObjNum, imageData);
    547     return pImage;
    548 }
    549 void CPDF_DocPageData::ReleaseImage(CPDF_Object* pImageStream)
    550 {
    551     if (!pImageStream) {
    552         return;
    553     }
    554     PDF_DocPageData_Release<FX_DWORD, CPDF_Image*>(m_ImageMap, pImageStream->GetObjNum(), NULL);
    555 }
    556 CPDF_IccProfile* CPDF_DocPageData::GetIccProfile(CPDF_Stream* pIccProfileStream, FX_INT32 nComponents)
    557 {
    558     if (!pIccProfileStream) {
    559         return NULL;
    560     }
    561     CPDF_CountedObject<CPDF_IccProfile*>* ipData = NULL;
    562     if (m_IccProfileMap.Lookup(pIccProfileStream, ipData)) {
    563         ipData->m_nCount++;
    564         return ipData->m_Obj;
    565     }
    566     CPDF_StreamAcc stream;
    567     stream.LoadAllData(pIccProfileStream, FALSE);
    568     FX_BYTE digest[20];
    569     CPDF_Stream* pCopiedStream = NULL;
    570     CRYPT_SHA1Generate(stream.GetData(), stream.GetSize(), digest);
    571     if (m_HashProfileMap.Lookup(CFX_ByteStringC(digest, 20), (void*&)pCopiedStream)) {
    572         m_IccProfileMap.Lookup(pCopiedStream, ipData);
    573         ipData->m_nCount++;
    574         return ipData->m_Obj;
    575     }
    576     CPDF_IccProfile* pProfile = FX_NEW CPDF_IccProfile(stream.GetData(), stream.GetSize(), nComponents);
    577     if (!pProfile) {
    578         return NULL;
    579     }
    580     ipData = FX_NEW CPDF_CountedObject<CPDF_IccProfile*>;
    581     if (!ipData) {
    582         delete pProfile;
    583         return NULL;
    584     }
    585     ipData->m_nCount = 2;
    586     ipData->m_Obj = pProfile;
    587     m_IccProfileMap.SetAt(pIccProfileStream, ipData);
    588     m_HashProfileMap.SetAt(CFX_ByteStringC(digest, 20), pIccProfileStream);
    589     return pProfile;
    590 }
    591 void CPDF_DocPageData::ReleaseIccProfile(CPDF_Stream* pIccProfileStream, CPDF_IccProfile* pIccProfile)
    592 {
    593     if (!pIccProfileStream && !pIccProfile) {
    594         return;
    595     }
    596     CPDF_CountedObject<CPDF_IccProfile*>* ipData = NULL;
    597     if (m_IccProfileMap.Lookup(pIccProfileStream, ipData) && ipData->m_nCount < 2) {
    598         FX_POSITION pos = m_HashProfileMap.GetStartPosition();
    599         while (pos) {
    600             CFX_ByteString key;
    601             CPDF_Stream* pFindStream = NULL;
    602             m_HashProfileMap.GetNextAssoc(pos, key, (void*&)pFindStream);
    603             if (pIccProfileStream == pFindStream) {
    604                 m_HashProfileMap.RemoveKey(key);
    605                 break;
    606             }
    607         }
    608     }
    609     PDF_DocPageData_Release<CPDF_Stream*, CPDF_IccProfile*>(m_IccProfileMap, pIccProfileStream, pIccProfile);
    610 }
    611 CPDF_StreamAcc* CPDF_DocPageData::GetFontFileStreamAcc(CPDF_Stream* pFontStream)
    612 {
    613     if (!pFontStream) {
    614         return NULL;
    615     }
    616     CPDF_CountedObject<CPDF_StreamAcc*>* ftData;
    617     if (m_FontFileMap.Lookup(pFontStream, ftData)) {
    618         ftData->m_nCount ++;
    619         return ftData->m_Obj;
    620     }
    621     ftData = FX_NEW CPDF_CountedObject<CPDF_StreamAcc*>;
    622     if (!ftData) {
    623         return NULL;
    624     }
    625     CPDF_StreamAcc* pFontFile = FX_NEW CPDF_StreamAcc;
    626     if (!pFontFile) {
    627         delete ftData;
    628         return NULL;
    629     }
    630     CPDF_Dictionary* pFontDict = pFontStream->GetDict();
    631     FX_INT32 org_size = pFontDict->GetInteger(FX_BSTRC("Length1")) + pFontDict->GetInteger(FX_BSTRC("Length2")) + pFontDict->GetInteger(FX_BSTRC("Length3"));
    632     if (org_size < 0) {
    633         org_size = 0;
    634     }
    635     pFontFile->LoadAllData(pFontStream, FALSE, org_size);
    636     ftData->m_nCount = 2;
    637     ftData->m_Obj = pFontFile;
    638     m_FontFileMap.SetAt(pFontStream, ftData);
    639     return pFontFile;
    640 }
    641 void CPDF_DocPageData::ReleaseFontFileStreamAcc(CPDF_Stream* pFontStream, FX_BOOL bForce)
    642 {
    643     if (!pFontStream) {
    644         return;
    645     }
    646     PDF_DocPageData_Release<CPDF_Stream*, CPDF_StreamAcc*>(m_FontFileMap, pFontStream, NULL, bForce);
    647 }
    648