Clean up CPDF_AnnotList.
[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_FontEncoding;
25 class CPDF_Form;
26 class CPDF_Function;
27 class CPDF_Image;
28 class CPDF_ImageObject;
29 class CPDF_Page;
30 class CPDF_Pattern;
31 class CPDF_RenderContext;
32 class CPDF_ShadingPattern;
33 class CPDF_TilingPattern;
34 class CPDF_ToUnicodeMap;
35 class CPDF_TrueTypeFont;
36 class CPDF_Type1Font;
37 class CPDF_Type3Font;
38 typedef struct FT_FaceRec_* FXFT_Face;
39
40 FX_WCHAR PDF_UnicodeFromAdobeName(const FX_CHAR* name);
41 CFX_ByteString PDF_AdobeNameFromUnicode(FX_WCHAR unicode);
42 const FX_CHAR* FCS_GetAltStr(FX_WCHAR unicode);
43 const FX_CHAR* PDF_CharNameFromPredefinedCharSet(int encoding,
44                                                  uint8_t charcode);
45
46 FX_WCHAR FT_UnicodeFromCharCode(int encoding, FX_DWORD charcode);
47 FX_DWORD FT_CharCodeFromUnicode(int encoding, FX_WCHAR unicode);
48 const FX_WORD* PDF_UnicodesForPredefinedCharSet(int encoding);
49 const FX_CHAR* GetAdobeCharName(int iBaseEncoding,
50                                 const CFX_ByteString* pCharNames,
51                                 int charcode);
52
53 template <class T>
54 class CPDF_CountedObject {
55  public:
56   explicit CPDF_CountedObject(T* ptr) : m_nCount(1), m_pObj(ptr) {}
57   void reset(T* ptr) {  // CAUTION: tosses prior ref counts.
58     m_nCount = 1;
59     m_pObj = ptr;
60   }
61   void clear() {  // Now you're all weak ptrs ...
62     delete m_pObj;
63     m_pObj = nullptr;
64   }
65   T* get() const { return m_pObj; }
66   T* AddRef() {
67     FXSYS_assert(m_pObj);
68     ++m_nCount;
69     return m_pObj;
70   }
71   void RemoveRef() {
72     if (m_nCount)
73       --m_nCount;
74   }
75   size_t use_count() const { return m_nCount; }
76
77  protected:
78   size_t m_nCount;
79   T* m_pObj;
80 };
81 using CPDF_CountedColorSpace = CPDF_CountedObject<CPDF_ColorSpace>;
82 using CPDF_CountedPattern = CPDF_CountedObject<CPDF_Pattern>;
83 #define PDFFONT_TYPE1 1
84 #define PDFFONT_TRUETYPE 2
85 #define PDFFONT_TYPE3 3
86 #define PDFFONT_CIDFONT 4
87 #define PDFFONT_FIXEDPITCH 1
88 #define PDFFONT_SERIF 2
89 #define PDFFONT_SYMBOLIC 4
90 #define PDFFONT_SCRIPT 8
91 #define PDFFONT_NONSYMBOLIC 32
92 #define PDFFONT_ITALIC 64
93 #define PDFFONT_ALLCAP 0x10000
94 #define PDFFONT_SMALLCAP 0x20000
95 #define PDFFONT_FORCEBOLD 0x40000
96 #define PDFFONT_USEEXTERNATTR 0x80000
97 class CPDF_Font {
98  public:
99   static CPDF_Font* CreateFontF(CPDF_Document* pDoc,
100                                 CPDF_Dictionary* pFontDict);
101   static CPDF_Font* GetStockFont(CPDF_Document* pDoc,
102                                  const CFX_ByteStringC& fontname);
103   static const FX_DWORD kInvalidCharCode = static_cast<FX_DWORD>(-1);
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 enum CIDSet {
418   CIDSET_UNKNOWN,
419   CIDSET_GB1,
420   CIDSET_CNS1,
421   CIDSET_JAPAN1,
422   CIDSET_KOREA1,
423   CIDSET_UNICODE,
424   CIDSET_NUM_SETS
425 };
426
427 class CPDF_CIDFont : public CPDF_Font {
428  public:
429   CPDF_CIDFont();
430
431   ~CPDF_CIDFont() override;
432
433   static FX_FLOAT CIDTransformToFloat(uint8_t ch);
434
435   FX_BOOL LoadGB2312();
436   int GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph = NULL) override;
437   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
438   void GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level = 0) override;
439   FX_WORD CIDFromCharCode(FX_DWORD charcode) const;
440
441   FX_BOOL IsTrueType() const { return !m_bType1; }
442
443   virtual FX_DWORD GetNextChar(const FX_CHAR* pString,
444                                int nStrLen,
445                                int& offset) const override;
446   int CountChar(const FX_CHAR* pString, int size) const override;
447   int AppendChar(FX_CHAR* str, FX_DWORD charcode) const override;
448   int GetCharSize(FX_DWORD charcode) const override;
449   const uint8_t* GetCIDTransform(FX_WORD CID) const;
450   FX_BOOL IsVertWriting() const override;
451   short GetVertWidth(FX_WORD CID) const;
452   void GetVertOrigin(FX_WORD CID, short& vx, short& vy) const;
453   FX_BOOL IsUnicodeCompatible() const override;
454   virtual FX_BOOL IsFontStyleFromCharCode(FX_DWORD charcode) const;
455
456  protected:
457   friend class CPDF_Font;
458
459   FX_BOOL _Load() override;
460   FX_WCHAR _UnicodeFromCharCode(FX_DWORD charcode) const override;
461   FX_DWORD _CharCodeFromUnicode(FX_WCHAR Unicode) const override;
462   int GetGlyphIndex(FX_DWORD unicodeb, FX_BOOL* pVertGlyph);
463   void LoadMetricsArray(CPDF_Array* pArray,
464                         CFX_DWordArray& result,
465                         int nElements);
466   void LoadSubstFont();
467
468   CPDF_CMap* m_pCMap;
469   CPDF_CMap* m_pAllocatedCMap;
470   CPDF_CID2UnicodeMap* m_pCID2UnicodeMap;
471   CIDSet m_Charset;
472   FX_BOOL m_bType1;
473   CPDF_StreamAcc* m_pCIDToGIDMap;
474   FX_BOOL m_bCIDIsGID;
475   FX_WORD m_DefaultWidth;
476   FX_WORD* m_pAnsiWidths;
477   FX_SMALL_RECT m_CharBBox[256];
478   CFX_DWordArray m_WidthList;
479   short m_DefaultVY;
480   short m_DefaultW1;
481   CFX_DWordArray m_VertMetrics;
482   FX_BOOL m_bAdobeCourierStd;
483   CFX_CTTGSUBTable* m_pTTGSUBTable;
484 };
485
486 #define PDFCS_DEVICEGRAY 1
487 #define PDFCS_DEVICERGB 2
488 #define PDFCS_DEVICECMYK 3
489 #define PDFCS_CALGRAY 4
490 #define PDFCS_CALRGB 5
491 #define PDFCS_LAB 6
492 #define PDFCS_ICCBASED 7
493 #define PDFCS_SEPARATION 8
494 #define PDFCS_DEVICEN 9
495 #define PDFCS_INDEXED 10
496 #define PDFCS_PATTERN 11
497
498 class CPDF_ColorSpace {
499  public:
500   static CPDF_ColorSpace* GetStockCS(int Family);
501
502   static CPDF_ColorSpace* Load(CPDF_Document* pDoc, CPDF_Object* pCSObj);
503
504   void ReleaseCS();
505
506   int GetBufSize() const;
507
508   FX_FLOAT* CreateBuf();
509
510   void GetDefaultColor(FX_FLOAT* buf) const;
511
512   int CountComponents() const { return m_nComponents; }
513
514   int GetFamily() const { return m_Family; }
515
516   virtual void GetDefaultValue(int iComponent,
517                                FX_FLOAT& value,
518                                FX_FLOAT& min,
519                                FX_FLOAT& max) const {
520     value = 0;
521     min = 0;
522     max = 1.0f;
523   }
524
525   FX_BOOL sRGB() const;
526
527   virtual FX_BOOL GetRGB(FX_FLOAT* pBuf,
528                          FX_FLOAT& R,
529                          FX_FLOAT& G,
530                          FX_FLOAT& B) const = 0;
531
532   virtual FX_BOOL SetRGB(FX_FLOAT* pBuf,
533                          FX_FLOAT R,
534                          FX_FLOAT G,
535                          FX_FLOAT B) const {
536     return FALSE;
537   }
538
539   FX_BOOL GetCMYK(FX_FLOAT* pBuf,
540                   FX_FLOAT& c,
541                   FX_FLOAT& m,
542                   FX_FLOAT& y,
543                   FX_FLOAT& k) const;
544
545   FX_BOOL SetCMYK(FX_FLOAT* pBuf,
546                   FX_FLOAT c,
547                   FX_FLOAT m,
548                   FX_FLOAT y,
549                   FX_FLOAT k) const;
550
551   virtual void TranslateImageLine(uint8_t* dest_buf,
552                                   const uint8_t* src_buf,
553                                   int pixels,
554                                   int image_width,
555                                   int image_height,
556                                   FX_BOOL bTransMask = FALSE) const;
557
558   CPDF_Array*& GetArray() { return m_pArray; }
559
560   int GetMaxIndex() const;
561
562   virtual CPDF_ColorSpace* GetBaseCS() const { return NULL; }
563
564   virtual void EnableStdConversion(FX_BOOL bEnabled);
565
566   CPDF_Document* const m_pDocument;
567
568  protected:
569   CPDF_ColorSpace(CPDF_Document* pDoc, int family, int nComponents)
570       : m_pDocument(pDoc),
571         m_Family(family),
572         m_nComponents(nComponents),
573         m_pArray(nullptr),
574         m_dwStdConversion(0) {}
575   virtual ~CPDF_ColorSpace() {}
576   virtual FX_BOOL v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
577     return TRUE;
578   }
579   virtual FX_BOOL v_GetCMYK(FX_FLOAT* pBuf,
580                             FX_FLOAT& c,
581                             FX_FLOAT& m,
582                             FX_FLOAT& y,
583                             FX_FLOAT& k) const {
584     return FALSE;
585   }
586   virtual FX_BOOL v_SetCMYK(FX_FLOAT* pBuf,
587                             FX_FLOAT c,
588                             FX_FLOAT m,
589                             FX_FLOAT y,
590                             FX_FLOAT k) const {
591     return FALSE;
592   }
593
594   int m_Family;
595
596   int m_nComponents;
597
598   CPDF_Array* m_pArray;
599
600   FX_DWORD m_dwStdConversion;
601 };
602 class CPDF_Color {
603  public:
604   CPDF_Color() : m_pCS(NULL), m_pBuffer(NULL) {}
605
606   CPDF_Color(int family);
607
608   ~CPDF_Color();
609
610   FX_BOOL IsNull() const { return m_pBuffer == NULL; }
611
612   FX_BOOL IsEqual(const CPDF_Color& other) const;
613
614   FX_BOOL IsPattern() const {
615     return m_pCS && m_pCS->GetFamily() == PDFCS_PATTERN;
616   }
617
618   void Copy(const CPDF_Color* pSrc);
619
620   void SetColorSpace(CPDF_ColorSpace* pCS);
621
622   void SetValue(FX_FLOAT* comp);
623
624   void SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comp, int ncomps);
625
626   FX_BOOL GetRGB(int& R, int& G, int& B) const;
627
628   CPDF_Pattern* GetPattern() const;
629
630   CPDF_ColorSpace* GetPatternCS() const;
631
632   FX_FLOAT* GetPatternColor() const;
633
634   CPDF_ColorSpace* m_pCS;
635
636  protected:
637   void ReleaseBuffer();
638   void ReleaseColorSpace();
639   FX_FLOAT* m_pBuffer;
640 };
641 #define PATTERN_TILING 1
642 #define PATTERN_SHADING 2
643 class CPDF_Pattern {
644  public:
645   virtual ~CPDF_Pattern();
646   void SetForceClear(FX_BOOL bForceClear) { m_bForceClear = bForceClear; }
647
648   CPDF_Object* m_pPatternObj;
649
650   int m_PatternType;
651
652   CFX_AffineMatrix m_Pattern2Form;
653   CFX_AffineMatrix m_ParentMatrix;
654
655   CPDF_Document* m_pDocument;
656
657  protected:
658   CPDF_Pattern(const CFX_AffineMatrix* pParentMatrix);
659   FX_BOOL m_bForceClear;
660 };
661
662 class CPDF_TilingPattern : public CPDF_Pattern {
663  public:
664   CPDF_TilingPattern(CPDF_Document* pDoc,
665                      CPDF_Object* pPatternObj,
666                      const CFX_AffineMatrix* parentMatrix);
667
668   ~CPDF_TilingPattern() override;
669
670   FX_BOOL Load();
671
672   FX_BOOL m_bColored;
673
674   CFX_FloatRect m_BBox;
675
676   FX_FLOAT m_XStep;
677
678   FX_FLOAT m_YStep;
679
680   CPDF_Form* m_pForm;
681 };
682
683 typedef enum {
684   kInvalidShading = 0,
685   kFunctionBasedShading = 1,
686   kAxialShading = 2,
687   kRadialShading = 3,
688   kFreeFormGouraudTriangleMeshShading = 4,
689   kLatticeFormGouraudTriangleMeshShading = 5,
690   kCoonsPatchMeshShading = 6,
691   kTensorProductPatchMeshShading = 7,
692   kMaxShading = 8
693 } ShadingType;
694
695 class CPDF_ShadingPattern : public CPDF_Pattern {
696  public:
697   CPDF_ShadingPattern(CPDF_Document* pDoc,
698                       CPDF_Object* pPatternObj,
699                       FX_BOOL bShading,
700                       const CFX_AffineMatrix* parentMatrix);
701
702   ~CPDF_ShadingPattern() override;
703
704   bool IsMeshShading() const {
705     return m_ShadingType == kFreeFormGouraudTriangleMeshShading ||
706            m_ShadingType == kLatticeFormGouraudTriangleMeshShading ||
707            m_ShadingType == kCoonsPatchMeshShading ||
708            m_ShadingType == kTensorProductPatchMeshShading;
709   }
710
711   CPDF_Object* m_pShadingObj;
712
713   FX_BOOL m_bShadingObj;
714
715   FX_BOOL Load();
716
717   FX_BOOL Reload();
718
719   ShadingType m_ShadingType;
720
721   CPDF_ColorSpace* m_pCS;  // Still keep m_pCS as some CPDF_ColorSpace (name
722                            // object) are not managed as counted objects. Refer
723                            // to CPDF_DocPageData::GetColorSpace.
724
725   CPDF_CountedColorSpace* m_pCountedCS;
726
727   CPDF_Function* m_pFunctions[4];
728
729   int m_nFuncs;
730
731  protected:
732   void Clear();
733 };
734 struct CPDF_MeshVertex {
735   FX_FLOAT x, y;
736   FX_FLOAT r, g, b;
737 };
738 class CPDF_MeshStream {
739  public:
740   FX_BOOL Load(CPDF_Stream* pShadingStream,
741                CPDF_Function** pFuncs,
742                int nFuncs,
743                CPDF_ColorSpace* pCS);
744
745   FX_DWORD GetFlag();
746
747   void GetCoords(FX_FLOAT& x, FX_FLOAT& y);
748
749   void GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b);
750
751   FX_DWORD GetVertex(CPDF_MeshVertex& vertex, CFX_AffineMatrix* pObject2Bitmap);
752
753   FX_BOOL GetVertexRow(CPDF_MeshVertex* vertex,
754                        int count,
755                        CFX_AffineMatrix* pObject2Bitmap);
756   CPDF_Function** m_pFuncs;
757   CPDF_ColorSpace* m_pCS;
758   FX_DWORD m_nFuncs, m_nCoordBits, m_nCompBits, m_nFlagBits, m_nComps;
759   FX_DWORD m_CoordMax, m_CompMax;
760   FX_FLOAT m_xmin, m_xmax, m_ymin, m_ymax;
761   FX_FLOAT m_ColorMin[8], m_ColorMax[8];
762   CPDF_StreamAcc m_Stream;
763   CFX_BitStream m_BitStream;
764 };
765 #define PDF_IMAGE_NO_COMPRESS 0x0000
766 #define PDF_IMAGE_LOSSY_COMPRESS 0x0001
767 #define PDF_IMAGE_LOSSLESS_COMPRESS 0x0002
768 #define PDF_IMAGE_MASK_LOSSY_COMPRESS 0x0004
769 #define PDF_IMAGE_MASK_LOSSLESS_COMPRESS 0x0008
770 class CPDF_ImageSetParam {
771  public:
772   CPDF_ImageSetParam() : pMatteColor(NULL), nQuality(80) {}
773   FX_ARGB* pMatteColor;
774   int32_t nQuality;
775 };
776 class CPDF_Image {
777  public:
778   CPDF_Image(CPDF_Document* pDoc);
779
780   ~CPDF_Image();
781
782   FX_BOOL LoadImageF(CPDF_Stream* pImageStream, FX_BOOL bInline);
783
784   void Release();
785
786   CPDF_Image* Clone();
787
788   FX_BOOL IsInline() { return m_bInline; }
789
790   void SetInlineDict(CPDF_Dictionary* pDict) { m_pInlineDict = pDict; }
791
792   CPDF_Dictionary* GetInlineDict() const { return m_pInlineDict; }
793
794   CPDF_Stream* GetStream() const { return m_pStream; }
795
796   CPDF_Dictionary* GetDict() const {
797     return m_pStream ? m_pStream->GetDict() : NULL;
798   }
799
800   CPDF_Dictionary* GetOC() const { return m_pOC; }
801
802   CPDF_Document* GetDocument() const { return m_pDocument; }
803
804   int32_t GetPixelHeight() const { return m_Height; }
805
806   int32_t GetPixelWidth() const { return m_Width; }
807
808   FX_BOOL IsMask() const { return m_bIsMask; }
809
810   FX_BOOL IsInterpol() const { return m_bInterpolate; }
811
812   CFX_DIBSource* LoadDIBSource(CFX_DIBSource** ppMask = NULL,
813                                FX_DWORD* pMatteColor = NULL,
814                                FX_BOOL bStdCS = FALSE,
815                                FX_DWORD GroupFamily = 0,
816                                FX_BOOL bLoadMask = FALSE) const;
817
818   void SetImage(const CFX_DIBitmap* pDIBitmap,
819                 int32_t iCompress,
820                 IFX_FileWrite* pFileWrite = NULL,
821                 IFX_FileRead* pFileRead = NULL,
822                 const CFX_DIBitmap* pMask = NULL,
823                 const CPDF_ImageSetParam* pParam = NULL);
824
825   void SetJpegImage(uint8_t* pImageData, FX_DWORD size);
826
827   void SetJpegImage(IFX_FileRead* pFile);
828
829   void ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pDIBitmap);
830
831  public:
832   FX_BOOL StartLoadDIBSource(CPDF_Dictionary* pFormResource,
833                              CPDF_Dictionary* pPageResource,
834                              FX_BOOL bStdCS = FALSE,
835                              FX_DWORD GroupFamily = 0,
836                              FX_BOOL bLoadMask = FALSE);
837   FX_BOOL Continue(IFX_Pause* pPause);
838   CFX_DIBSource* DetachBitmap();
839   CFX_DIBSource* DetachMask();
840   CFX_DIBSource* m_pDIBSource;
841   CFX_DIBSource* m_pMask;
842   FX_DWORD m_MatteColor;
843
844  private:
845   CPDF_Stream* m_pStream;
846   FX_BOOL m_bInline;
847   CPDF_Dictionary* m_pInlineDict;
848
849   int32_t m_Height;
850
851   int32_t m_Width;
852
853   FX_BOOL m_bIsMask;
854
855   FX_BOOL m_bInterpolate;
856
857   CPDF_Document* m_pDocument;
858
859   CPDF_Dictionary* m_pOC;
860   CPDF_Dictionary* InitJPEG(uint8_t* pData, FX_DWORD size);
861 };
862
863 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_