Use override in more classes in core/
[pdfium.git] / core / include / fpdfapi / fpdf_resource.h
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 #ifndef CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
8 #define CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
9
10 #include "../fxcrt/fx_system.h"
11 #include "../fxge/fx_font.h"
12 #include "fpdf_parser.h"
13
14 class CFX_CTTGSUBTable;
15 class CFX_DIBitmap;
16 class CFX_Font;
17 class CFX_SubstFont;
18 class CPDF_CID2UnicodeMap;
19 class CPDF_CIDFont;
20 class CPDF_CMap;
21 class CPDF_Color;
22 class CPDF_ColorSpace;
23 class CPDF_Face;
24 class CPDF_Font;
25 class CPDF_FontEncoding;
26 class CPDF_Form;
27 class CPDF_Function;
28 class CPDF_Image;
29 class CPDF_ImageObject;
30 class CPDF_Page;
31 class CPDF_Pattern;
32 class CPDF_RenderContext;
33 class CPDF_ShadingPattern;
34 class CPDF_TilingPattern;
35 class CPDF_ToUnicodeMap;
36 class CPDF_TrueTypeFont;
37 class CPDF_Type1Font;
38 class CPDF_Type3Font;
39 typedef struct FT_FaceRec_* FXFT_Face;
40
41 FX_WCHAR PDF_UnicodeFromAdobeName(const FX_CHAR* name);
42 CFX_ByteString PDF_AdobeNameFromUnicode(FX_WCHAR unicode);
43 const FX_CHAR* FCS_GetAltStr(FX_WCHAR unicode);
44 const FX_CHAR* PDF_CharNameFromPredefinedCharSet(int encoding,
45                                                  uint8_t charcode);
46
47 FX_WCHAR FT_UnicodeFromCharCode(int encoding, FX_DWORD charcode);
48 FX_DWORD FT_CharCodeFromUnicode(int encoding, FX_WCHAR unicode);
49 const FX_WORD* PDF_UnicodesForPredefinedCharSet(int encoding);
50 const FX_CHAR* GetAdobeCharName(int iBaseEncoding,
51                                 const CFX_ByteString* pCharNames,
52                                 int charcode);
53
54 template <class T>
55 class CPDF_CountedObject {
56  public:
57   explicit CPDF_CountedObject(T* ptr) : m_nCount(1), m_pObj(ptr) {}
58   void reset(T* ptr) {  // CAUTION: tosses prior ref counts.
59     m_nCount = 1;
60     m_pObj = ptr;
61   }
62   void clear() {  // Now you're all weak ptrs ...
63     delete m_pObj;
64     m_pObj = nullptr;
65   }
66   T* get() const { return m_pObj; }
67   T* AddRef() {
68     FXSYS_assert(m_pObj);
69     ++m_nCount;
70     return m_pObj;
71   }
72   void RemoveRef() {
73     if (m_nCount)
74       --m_nCount;
75   }
76   size_t use_count() const { return m_nCount; }
77
78  protected:
79   size_t m_nCount;
80   T* m_pObj;
81 };
82 using CPDF_CountedColorSpace = CPDF_CountedObject<CPDF_ColorSpace>;
83 using CPDF_CountedPattern = CPDF_CountedObject<CPDF_Pattern>;
84 #define PDFFONT_TYPE1 1
85 #define PDFFONT_TRUETYPE 2
86 #define PDFFONT_TYPE3 3
87 #define PDFFONT_CIDFONT 4
88 #define PDFFONT_FIXEDPITCH 1
89 #define PDFFONT_SERIF 2
90 #define PDFFONT_SYMBOLIC 4
91 #define PDFFONT_SCRIPT 8
92 #define PDFFONT_NONSYMBOLIC 32
93 #define PDFFONT_ITALIC 64
94 #define PDFFONT_ALLCAP 0x10000
95 #define PDFFONT_SMALLCAP 0x20000
96 #define PDFFONT_FORCEBOLD 0x40000
97 #define PDFFONT_USEEXTERNATTR 0x80000
98 class CPDF_Font {
99  public:
100   static CPDF_Font* CreateFontF(CPDF_Document* pDoc,
101                                 CPDF_Dictionary* pFontDict);
102   static CPDF_Font* GetStockFont(CPDF_Document* pDoc,
103                                  const CFX_ByteStringC& fontname);
104
105   virtual ~CPDF_Font();
106
107   bool IsFontType(int fonttype) const { return fonttype == m_FontType; }
108   int GetFontType() const { return m_FontType; }
109
110   CFX_ByteString GetFontTypeName() const;
111
112   const CFX_ByteString& GetBaseFont() const { return m_BaseFont; }
113
114   const CFX_SubstFont* GetSubstFont() const { return m_Font.GetSubstFont(); }
115
116   FX_DWORD GetFlags() const { return m_Flags; }
117
118   virtual FX_BOOL IsVertWriting() const;
119
120   CPDF_Type1Font* GetType1Font() const {
121     return m_FontType == PDFFONT_TYPE1 ? (CPDF_Type1Font*)(void*)this : NULL;
122   }
123
124   CPDF_TrueTypeFont* GetTrueTypeFont() const {
125     return m_FontType == PDFFONT_TRUETYPE ? (CPDF_TrueTypeFont*)(void*)this
126                                           : NULL;
127   }
128
129   CPDF_CIDFont* GetCIDFont() const {
130     return (m_FontType == PDFFONT_CIDFONT) ? (CPDF_CIDFont*)(void*)this : NULL;
131   }
132
133   CPDF_Type3Font* GetType3Font() const {
134     return (m_FontType == PDFFONT_TYPE3) ? (CPDF_Type3Font*)(void*)this : NULL;
135   }
136
137   FX_BOOL IsEmbedded() const {
138     return m_FontType == PDFFONT_TYPE3 || m_pFontFile != NULL;
139   }
140
141   virtual FX_BOOL IsUnicodeCompatible() const { return FALSE; }
142
143   CPDF_StreamAcc* GetFontFile() const { return m_pFontFile; }
144
145   CPDF_Dictionary* GetFontDict() const { return m_pFontDict; }
146
147   FX_BOOL IsStandardFont() const;
148
149   FXFT_Face GetFace() const { return m_Font.GetFace(); }
150
151   virtual FX_DWORD GetNextChar(const FX_CHAR* pString,
152                                int nStrLen,
153                                int& offset) const {
154     if (offset < 0 || nStrLen < 1) {
155       return 0;
156     }
157     uint8_t ch = offset < nStrLen ? pString[offset++] : pString[nStrLen - 1];
158     return static_cast<FX_DWORD>(ch);
159   }
160
161   virtual int CountChar(const FX_CHAR* pString, int size) const { return size; }
162
163   void AppendChar(CFX_ByteString& str, FX_DWORD charcode) const;
164
165   virtual int AppendChar(FX_CHAR* buf, FX_DWORD charcode) const {
166     *buf = (FX_CHAR)charcode;
167     return 1;
168   }
169
170   virtual int GetCharSize(FX_DWORD charcode) const { return 1; }
171
172   virtual int GlyphFromCharCode(FX_DWORD charcode,
173                                 FX_BOOL* pVertGlyph = NULL) = 0;
174   virtual int GlyphFromCharCodeExt(FX_DWORD charcode) {
175     return GlyphFromCharCode(charcode);
176   }
177
178   CFX_WideString UnicodeFromCharCode(FX_DWORD charcode) const;
179
180   FX_DWORD CharCodeFromUnicode(FX_WCHAR Unicode) const;
181
182   CFX_CharMap* GetCharMap() { return m_pCharMap; }
183
184   CFX_ByteString EncodeString(const CFX_WideString& str) const;
185
186   CFX_WideString DecodeString(const CFX_ByteString& str) const;
187
188   void GetFontBBox(FX_RECT& rect) const { rect = m_FontBBox; }
189
190   int GetTypeAscent() const { return m_Ascent; }
191
192   int GetTypeDescent() const { return m_Descent; }
193
194   int GetItalicAngle() const { return m_ItalicAngle; }
195
196   int GetStemV() const { return m_StemV; }
197
198   int GetStringWidth(const FX_CHAR* pString, int size);
199
200   virtual int GetCharWidthF(FX_DWORD charcode, int level = 0) = 0;
201
202   virtual int GetCharTypeWidth(FX_DWORD charcode);
203
204   virtual void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) = 0;
205
206   CPDF_Document* m_pDocument;
207
208   class CFX_PathData* LoadGlyphPath(FX_DWORD charcode, int dest_width = 0);
209
210   CFX_Font m_Font;
211
212  protected:
213   explicit CPDF_Font(int fonttype);
214
215   FX_BOOL Initialize();
216
217   FX_BOOL Load();
218
219   virtual FX_BOOL _Load() = 0;
220
221   virtual FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const = 0;
222
223   virtual FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const = 0;
224
225   void LoadUnicodeMap();
226
227   void LoadPDFEncoding(CPDF_Object* pEncoding,
228                        int& iBaseEncoding,
229                        CFX_ByteString*& pCharNames,
230                        FX_BOOL bEmbedded,
231                        FX_BOOL bTrueType);
232
233   void LoadFontDescriptor(CPDF_Dictionary*);
234
235   void LoadCharWidths(FX_WORD* pWidths);
236
237   void CheckFontMetrics();
238
239   CFX_CharMap* m_pCharMap;
240
241   CFX_ByteString m_BaseFont;
242
243   CPDF_StreamAcc* m_pFontFile;
244
245   CPDF_Dictionary* m_pFontDict;
246
247   CPDF_ToUnicodeMap* m_pToUnicodeMap;
248
249   FX_BOOL m_bToUnicodeLoaded;
250
251   int m_Flags;
252
253   FX_RECT m_FontBBox;
254
255   int m_StemV;
256
257   int m_Ascent;
258
259   int m_Descent;
260
261   int m_ItalicAngle;
262
263  private:
264   const int m_FontType;
265 };
266 #define PDFFONT_ENCODING_BUILTIN 0
267 #define PDFFONT_ENCODING_WINANSI 1
268 #define PDFFONT_ENCODING_MACROMAN 2
269 #define PDFFONT_ENCODING_MACEXPERT 3
270 #define PDFFONT_ENCODING_STANDARD 4
271 #define PDFFONT_ENCODING_ADOBE_SYMBOL 5
272 #define PDFFONT_ENCODING_ZAPFDINGBATS 6
273 #define PDFFONT_ENCODING_PDFDOC 7
274 #define PDFFONT_ENCODING_MS_SYMBOL 8
275 #define PDFFONT_ENCODING_UNICODE 9
276 class CPDF_FontEncoding {
277  public:
278   CPDF_FontEncoding();
279
280   CPDF_FontEncoding(int PredefinedEncoding);
281
282   void LoadEncoding(CPDF_Object* pEncoding);
283
284   FX_BOOL IsIdentical(CPDF_FontEncoding* pAnother) const;
285
286   FX_WCHAR UnicodeFromCharCode(uint8_t charcode) const {
287     return m_Unicodes[charcode];
288   }
289
290   int CharCodeFromUnicode(FX_WCHAR unicode) const;
291
292   void SetUnicode(uint8_t charcode, FX_WCHAR unicode) {
293     m_Unicodes[charcode] = unicode;
294   }
295
296   CPDF_Object* Realize();
297
298  public:
299   FX_WCHAR m_Unicodes[256];
300 };
301
302 class CPDF_SimpleFont : public CPDF_Font {
303  public:
304   explicit CPDF_SimpleFont(int fonttype);
305   ~CPDF_SimpleFont() override;
306
307   CPDF_FontEncoding* GetEncoding() { return &m_Encoding; }
308   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
309   void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
310   int GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph = NULL) override;
311   FX_BOOL IsUnicodeCompatible() const override;
312
313  protected:
314   FX_BOOL LoadCommon();
315
316   void LoadSubstFont();
317
318   void LoadFaceMetrics();
319
320   virtual void LoadGlyphMap() = 0;
321
322   FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const override {
323     return m_Encoding.UnicodeFromCharCode((uint8_t)charcode);
324   }
325
326   FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const override {
327     return m_Encoding.CharCodeFromUnicode(Unicode);
328   }
329
330   void LoadCharMetrics(int charcode);
331
332   CPDF_FontEncoding m_Encoding;
333   FX_WORD m_GlyphIndex[256];
334   FX_WORD m_ExtGID[256];
335   CFX_ByteString* m_pCharNames;
336   int m_BaseEncoding;
337   FX_WORD m_CharWidth[256];
338   FX_SMALL_RECT m_CharBBox[256];
339   FX_BOOL m_bUseFontWidth;
340 };
341
342 class CPDF_Type1Font : public CPDF_SimpleFont {
343  public:
344   CPDF_Type1Font();
345
346   int GetBase14Font() { return m_Base14Font; }
347   virtual int GlyphFromCharCodeExt(FX_DWORD charcode);
348
349  protected:
350   virtual FX_BOOL _Load();
351
352   int m_Base14Font;
353   virtual void LoadGlyphMap();
354 };
355 class CPDF_TrueTypeFont : public CPDF_SimpleFont {
356  public:
357   CPDF_TrueTypeFont();
358
359  protected:
360   virtual FX_BOOL _Load();
361   virtual void LoadGlyphMap();
362 };
363 class CPDF_Type3Char {
364  public:
365   CPDF_Type3Char();
366
367   ~CPDF_Type3Char();
368
369   FX_BOOL LoadBitmap(CPDF_RenderContext* pContext);
370
371   FX_BOOL m_bColored;
372
373   FX_BOOL m_bPageRequired;
374
375   CPDF_Form* m_pForm;
376
377   CFX_AffineMatrix m_ImageMatrix;
378
379   CFX_DIBitmap* m_pBitmap;
380
381   int m_Width;
382
383   FX_RECT m_BBox;
384 };
385 class CPDF_Type3Font : public CPDF_SimpleFont {
386  public:
387   CPDF_Type3Font();
388   ~CPDF_Type3Font() override;
389
390   void SetPageResources(CPDF_Dictionary* pResources) {
391     m_pPageResources = pResources;
392   }
393   CPDF_Type3Char* LoadChar(FX_DWORD charcode, int level = 0);
394   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
395   int GetCharTypeWidth(FX_DWORD charcode) override {
396     return GetCharWidthF(charcode);
397   }
398   void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
399   CFX_AffineMatrix& GetFontMatrix() { return m_FontMatrix; }
400   void CheckType3FontMetrics();
401
402  protected:
403   CFX_AffineMatrix m_FontMatrix;
404
405  private:
406   FX_BOOL _Load() override;
407   void LoadGlyphMap() override {}
408
409   int m_CharWidthL[256];
410   CPDF_Dictionary* m_pCharProcs;
411   CPDF_Dictionary* m_pPageResources;
412   CPDF_Dictionary* m_pFontResources;
413   CFX_MapPtrToPtr m_CacheMap;
414   CFX_MapPtrToPtr m_DeletedMap;
415 };
416
417 #define CIDSET_UNKNOWN 0
418 #define CIDSET_GB1 1
419 #define CIDSET_CNS1 2
420 #define CIDSET_JAPAN1 3
421 #define CIDSET_KOREA1 4
422 #define CIDSET_UNICODE 5
423 #define NUMBER_OF_CIDSETS 6
424
425 class CPDF_CIDFont : public CPDF_Font {
426  public:
427   CPDF_CIDFont();
428
429   ~CPDF_CIDFont() override;
430
431   FX_BOOL LoadGB2312();
432   int GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph = NULL) override;
433   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
434   void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
435   FX_WORD CIDFromCharCode(FX_DWORD charcode) const;
436
437   FX_BOOL IsTrueType() const { return !m_bType1; }
438
439   virtual FX_DWORD GetNextChar(const FX_CHAR* pString,
440                                int nStrLen,
441                                int& offset) const override;
442   int CountChar(const FX_CHAR* pString, int size) const override;
443   int AppendChar(FX_CHAR* str, FX_DWORD charcode) const override;
444   int GetCharSize(FX_DWORD charcode) const override;
445
446   int GetCharset() const { return m_Charset; }
447
448   const uint8_t* GetCIDTransform(FX_WORD CID) const;
449   FX_BOOL IsVertWriting() const override;
450   short GetVertWidth(FX_WORD CID) const;
451   void GetVertOrigin(FX_WORD CID, short& vx, short& vy) const;
452   FX_BOOL IsUnicodeCompatible() const override;
453   virtual FX_BOOL IsFontStyleFromCharCode(FX_DWORD charcode) const;
454
455  protected:
456   friend class CPDF_Font;
457
458   FX_BOOL _Load() override;
459   FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const override;
460   FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const override;
461   int GetGlyphIndex(FX_DWORD unicodeb, FX_BOOL* pVertGlyph);
462   void LoadMetricsArray(CPDF_Array* pArray,
463                         CFX_DWordArray& result,
464                         int nElements);
465   void LoadSubstFont();
466
467   CPDF_CMap* m_pCMap;
468   CPDF_CMap* m_pAllocatedCMap;
469   CPDF_CID2UnicodeMap* m_pCID2UnicodeMap;
470   int m_Charset;
471   FX_BOOL m_bType1;
472   CPDF_StreamAcc* m_pCIDToGIDMap;
473   FX_BOOL m_bCIDIsGID;
474   FX_WORD m_DefaultWidth;
475   FX_WORD* m_pAnsiWidths;
476   FX_SMALL_RECT m_CharBBox[256];
477   CFX_DWordArray m_WidthList;
478   short m_DefaultVY;
479   short m_DefaultW1;
480   CFX_DWordArray m_VertMetrics;
481   FX_BOOL m_bAdobeCourierStd;
482   CFX_CTTGSUBTable* m_pTTGSUBTable;
483 };
484
485 #define PDFCS_DEVICEGRAY 1
486 #define PDFCS_DEVICERGB 2
487 #define PDFCS_DEVICECMYK 3
488 #define PDFCS_CALGRAY 4
489 #define PDFCS_CALRGB 5
490 #define PDFCS_LAB 6
491 #define PDFCS_ICCBASED 7
492 #define PDFCS_SEPARATION 8
493 #define PDFCS_DEVICEN 9
494 #define PDFCS_INDEXED 10
495 #define PDFCS_PATTERN 11
496
497 class CPDF_ColorSpace {
498  public:
499   static CPDF_ColorSpace* GetStockCS(int Family);
500
501   static CPDF_ColorSpace* Load(CPDF_Document* pDoc, CPDF_Object* pCSObj);
502
503   void ReleaseCS();
504
505   int GetBufSize() const;
506
507   FX_FLOAT* CreateBuf();
508
509   void GetDefaultColor(FX_FLOAT* buf) const;
510
511   int CountComponents() const { return m_nComponents; }
512
513   int GetFamily() const { return m_Family; }
514
515   virtual void GetDefaultValue(int iComponent,
516                                FX_FLOAT& value,
517                                FX_FLOAT& min,
518                                FX_FLOAT& max) const {
519     value = 0;
520     min = 0;
521     max = 1.0f;
522   }
523
524   FX_BOOL sRGB() const;
525
526   virtual FX_BOOL GetRGB(FX_FLOAT* pBuf,
527                          FX_FLOAT& R,
528                          FX_FLOAT& G,
529                          FX_FLOAT& B) const = 0;
530
531   virtual FX_BOOL SetRGB(FX_FLOAT* pBuf,
532                          FX_FLOAT R,
533                          FX_FLOAT G,
534                          FX_FLOAT B) const {
535     return FALSE;
536   }
537
538   FX_BOOL GetCMYK(FX_FLOAT* pBuf,
539                   FX_FLOAT& c,
540                   FX_FLOAT& m,
541                   FX_FLOAT& y,
542                   FX_FLOAT& k) const;
543
544   FX_BOOL SetCMYK(FX_FLOAT* pBuf,
545                   FX_FLOAT c,
546                   FX_FLOAT m,
547                   FX_FLOAT y,
548                   FX_FLOAT k) const;
549
550   virtual void TranslateImageLine(uint8_t* dest_buf,
551                                   const uint8_t* src_buf,
552                                   int pixels,
553                                   int image_width,
554                                   int image_height,
555                                   FX_BOOL bTransMask = FALSE) const;
556
557   CPDF_Array*& GetArray() { return m_pArray; }
558
559   int GetMaxIndex() const;
560
561   virtual CPDF_ColorSpace* GetBaseCS() const { return NULL; }
562
563   virtual void EnableStdConversion(FX_BOOL bEnabled);
564
565   CPDF_Document* const m_pDocument;
566
567  protected:
568   CPDF_ColorSpace(CPDF_Document* pDoc, int family, int nComponents)
569       : m_pDocument(pDoc),
570         m_Family(family),
571         m_nComponents(nComponents),
572         m_pArray(nullptr),
573         m_dwStdConversion(0) {}
574   virtual ~CPDF_ColorSpace() {}
575   virtual FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
576     return TRUE;
577   }
578   virtual FX_BOOL v_GetCMYK(FX_FLOAT* pBuf,
579                             FX_FLOAT& c,
580                             FX_FLOAT& m,
581                             FX_FLOAT& y,
582                             FX_FLOAT& k) const {
583     return FALSE;
584   }
585   virtual FX_BOOL v_SetCMYK(FX_FLOAT* pBuf,
586                             FX_FLOAT c,
587                             FX_FLOAT m,
588                             FX_FLOAT y,
589                             FX_FLOAT k) const {
590     return FALSE;
591   }
592
593   int m_Family;
594
595   int m_nComponents;
596
597   CPDF_Array* m_pArray;
598
599   FX_DWORD m_dwStdConversion;
600 };
601 class CPDF_Color {
602  public:
603   CPDF_Color() : m_pCS(NULL), m_pBuffer(NULL) {}
604
605   CPDF_Color(int family);
606
607   ~CPDF_Color();
608
609   FX_BOOL IsNull() const { return m_pBuffer == NULL; }
610
611   FX_BOOL IsEqual(const CPDF_Color& other) const;
612
613   FX_BOOL IsPattern() const {
614     return m_pCS && m_pCS->GetFamily() == PDFCS_PATTERN;
615   }
616
617   void Copy(const CPDF_Color* pSrc);
618
619   void SetColorSpace(CPDF_ColorSpace* pCS);
620
621   void SetValue(FX_FLOAT* comp);
622
623   void SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comp, int ncomps);
624
625   FX_BOOL GetRGB(int& R, int& G, int& B) const;
626
627   CPDF_Pattern* GetPattern() const;
628
629   CPDF_ColorSpace* GetPatternCS() const;
630
631   FX_FLOAT* GetPatternColor() const;
632
633   CPDF_ColorSpace* m_pCS;
634
635  protected:
636   void ReleaseBuffer();
637   void ReleaseColorSpace();
638   FX_FLOAT* m_pBuffer;
639 };
640 #define PATTERN_TILING 1
641 #define PATTERN_SHADING 2
642 class CPDF_Pattern {
643  public:
644   virtual ~CPDF_Pattern();
645   void SetForceClear(FX_BOOL bForceClear) { m_bForceClear = bForceClear; }
646
647   CPDF_Object* m_pPatternObj;
648
649   int m_PatternType;
650
651   CFX_AffineMatrix m_Pattern2Form;
652   CFX_AffineMatrix m_ParentMatrix;
653
654   CPDF_Document* m_pDocument;
655
656  protected:
657   CPDF_Pattern(const CFX_AffineMatrix* pParentMatrix);
658   FX_BOOL m_bForceClear;
659 };
660
661 class CPDF_TilingPattern : public CPDF_Pattern {
662  public:
663   CPDF_TilingPattern(CPDF_Document* pDoc,
664                      CPDF_Object* pPatternObj,
665                      const CFX_AffineMatrix* parentMatrix);
666
667   ~CPDF_TilingPattern() override;
668
669   FX_BOOL Load();
670
671   FX_BOOL m_bColored;
672
673   CFX_FloatRect m_BBox;
674
675   FX_FLOAT m_XStep;
676
677   FX_FLOAT m_YStep;
678
679   CPDF_Form* m_pForm;
680 };
681 class CPDF_ShadingPattern : public CPDF_Pattern {
682  public:
683   CPDF_ShadingPattern(CPDF_Document* pDoc,
684                       CPDF_Object* pPatternObj,
685                       FX_BOOL bShading,
686                       const CFX_AffineMatrix* parentMatrix);
687
688   ~CPDF_ShadingPattern() override;
689
690   CPDF_Object* m_pShadingObj;
691
692   FX_BOOL m_bShadingObj;
693
694   FX_BOOL Load();
695
696   FX_BOOL Reload();
697
698   int m_ShadingType;
699
700   CPDF_ColorSpace* m_pCS;  // Still keep m_pCS as some CPDF_ColorSpace (name
701                            // object) are not managed as counted objects. Refer
702                            // to CPDF_DocPageData::GetColorSpace.
703
704   CPDF_CountedColorSpace* m_pCountedCS;
705
706   CPDF_Function* m_pFunctions[4];
707
708   int m_nFuncs;
709
710  protected:
711   void Clear();
712 };
713 struct CPDF_MeshVertex {
714   FX_FLOAT x, y;
715   FX_FLOAT r, g, b;
716 };
717 class CPDF_MeshStream {
718  public:
719   FX_BOOL Load(CPDF_Stream* pShadingStream,
720                CPDF_Function** pFuncs,
721                int nFuncs,
722                CPDF_ColorSpace* pCS);
723
724   FX_DWORD GetFlag();
725
726   void GetCoords(FX_FLOAT& x, FX_FLOAT& y);
727
728   void GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b);
729
730   FX_DWORD GetVertex(CPDF_MeshVertex& vertex, CFX_AffineMatrix* pObject2Bitmap);
731
732   FX_BOOL GetVertexRow(CPDF_MeshVertex* vertex,
733                        int count,
734                        CFX_AffineMatrix* pObject2Bitmap);
735   CPDF_Function** m_pFuncs;
736   CPDF_ColorSpace* m_pCS;
737   FX_DWORD m_nFuncs, m_nCoordBits, m_nCompBits, m_nFlagBits, m_nComps;
738   FX_DWORD m_CoordMax, m_CompMax;
739   FX_FLOAT m_xmin, m_xmax, m_ymin, m_ymax;
740   FX_FLOAT m_ColorMin[8], m_ColorMax[8];
741   CPDF_StreamAcc m_Stream;
742   CFX_BitStream m_BitStream;
743 };
744 #define PDF_IMAGE_NO_COMPRESS 0x0000
745 #define PDF_IMAGE_LOSSY_COMPRESS 0x0001
746 #define PDF_IMAGE_LOSSLESS_COMPRESS 0x0002
747 #define PDF_IMAGE_MASK_LOSSY_COMPRESS 0x0004
748 #define PDF_IMAGE_MASK_LOSSLESS_COMPRESS 0x0008
749 class CPDF_ImageSetParam {
750  public:
751   CPDF_ImageSetParam() : pMatteColor(NULL), nQuality(80) {}
752   FX_ARGB* pMatteColor;
753   int32_t nQuality;
754 };
755 class CPDF_Image {
756  public:
757   CPDF_Image(CPDF_Document* pDoc);
758
759   ~CPDF_Image();
760
761   FX_BOOL LoadImageF(CPDF_Stream* pImageStream, FX_BOOL bInline);
762
763   void Release();
764
765   CPDF_Image* Clone();
766
767   FX_BOOL IsInline() { return m_bInline; }
768
769   void SetInlineDict(CPDF_Dictionary* pDict) { m_pInlineDict = pDict; }
770
771   CPDF_Dictionary* GetInlineDict() const { return m_pInlineDict; }
772
773   CPDF_Stream* GetStream() const { return m_pStream; }
774
775   CPDF_Dictionary* GetDict() const {
776     return m_pStream ? m_pStream->GetDict() : NULL;
777   }
778
779   CPDF_Dictionary* GetOC() const { return m_pOC; }
780
781   CPDF_Document* GetDocument() const { return m_pDocument; }
782
783   int32_t GetPixelHeight() const { return m_Height; }
784
785   int32_t GetPixelWidth() const { return m_Width; }
786
787   FX_BOOL IsMask() const { return m_bIsMask; }
788
789   FX_BOOL IsInterpol() const { return m_bInterpolate; }
790
791   CFX_DIBSource* LoadDIBSource(CFX_DIBSource** ppMask = NULL,
792                                FX_DWORD* pMatteColor = NULL,
793                                FX_BOOL bStdCS = FALSE,
794                                FX_DWORD GroupFamily = 0,
795                                FX_BOOL bLoadMask = FALSE) const;
796
797   void SetImage(const CFX_DIBitmap* pDIBitmap,
798                 int32_t iCompress,
799                 IFX_FileWrite* pFileWrite = NULL,
800                 IFX_FileRead* pFileRead = NULL,
801                 const CFX_DIBitmap* pMask = NULL,
802                 const CPDF_ImageSetParam* pParam = NULL);
803
804   void SetJpegImage(uint8_t* pImageData, FX_DWORD size);
805
806   void SetJpegImage(IFX_FileRead* pFile);
807
808   void ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pDIBitmap);
809
810  public:
811   FX_BOOL StartLoadDIBSource(CPDF_Dictionary* pFormResource,
812                              CPDF_Dictionary* pPageResource,
813                              FX_BOOL bStdCS = FALSE,
814                              FX_DWORD GroupFamily = 0,
815                              FX_BOOL bLoadMask = FALSE);
816   FX_BOOL Continue(IFX_Pause* pPause);
817   CFX_DIBSource* DetachBitmap();
818   CFX_DIBSource* DetachMask();
819   CFX_DIBSource* m_pDIBSource;
820   CFX_DIBSource* m_pMask;
821   FX_DWORD m_MatteColor;
822
823  private:
824   CPDF_Stream* m_pStream;
825   FX_BOOL m_bInline;
826   CPDF_Dictionary* m_pInlineDict;
827
828   int32_t m_Height;
829
830   int32_t m_Width;
831
832   FX_BOOL m_bIsMask;
833
834   FX_BOOL m_bInterpolate;
835
836   CPDF_Document* m_pDocument;
837
838   CPDF_Dictionary* m_pOC;
839   CPDF_Dictionary* InitJPEG(uint8_t* pData, FX_DWORD size);
840 };
841
842 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_