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