Add type cast definitions for CPDF_Array.
[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 class CPDF_ShadingPattern : public CPDF_Pattern {
683  public:
684   CPDF_ShadingPattern(CPDF_Document* pDoc,
685                       CPDF_Object* pPatternObj,
686                       FX_BOOL bShading,
687                       const CFX_AffineMatrix* parentMatrix);
688
689   ~CPDF_ShadingPattern() override;
690
691   CPDF_Object* m_pShadingObj;
692
693   FX_BOOL m_bShadingObj;
694
695   FX_BOOL Load();
696
697   FX_BOOL Reload();
698
699   int m_ShadingType;
700
701   CPDF_ColorSpace* m_pCS;  // Still keep m_pCS as some CPDF_ColorSpace (name
702                            // object) are not managed as counted objects. Refer
703                            // to CPDF_DocPageData::GetColorSpace.
704
705   CPDF_CountedColorSpace* m_pCountedCS;
706
707   CPDF_Function* m_pFunctions[4];
708
709   int m_nFuncs;
710
711  protected:
712   void Clear();
713 };
714 struct CPDF_MeshVertex {
715   FX_FLOAT x, y;
716   FX_FLOAT r, g, b;
717 };
718 class CPDF_MeshStream {
719  public:
720   FX_BOOL Load(CPDF_Stream* pShadingStream,
721                CPDF_Function** pFuncs,
722                int nFuncs,
723                CPDF_ColorSpace* pCS);
724
725   FX_DWORD GetFlag();
726
727   void GetCoords(FX_FLOAT& x, FX_FLOAT& y);
728
729   void GetColor(FX_FLOAT& r, FX_FLOAT& g, FX_FLOAT& b);
730
731   FX_DWORD GetVertex(CPDF_MeshVertex& vertex, CFX_AffineMatrix* pObject2Bitmap);
732
733   FX_BOOL GetVertexRow(CPDF_MeshVertex* vertex,
734                        int count,
735                        CFX_AffineMatrix* pObject2Bitmap);
736   CPDF_Function** m_pFuncs;
737   CPDF_ColorSpace* m_pCS;
738   FX_DWORD m_nFuncs, m_nCoordBits, m_nCompBits, m_nFlagBits, m_nComps;
739   FX_DWORD m_CoordMax, m_CompMax;
740   FX_FLOAT m_xmin, m_xmax, m_ymin, m_ymax;
741   FX_FLOAT m_ColorMin[8], m_ColorMax[8];
742   CPDF_StreamAcc m_Stream;
743   CFX_BitStream m_BitStream;
744 };
745 #define PDF_IMAGE_NO_COMPRESS 0x0000
746 #define PDF_IMAGE_LOSSY_COMPRESS 0x0001
747 #define PDF_IMAGE_LOSSLESS_COMPRESS 0x0002
748 #define PDF_IMAGE_MASK_LOSSY_COMPRESS 0x0004
749 #define PDF_IMAGE_MASK_LOSSLESS_COMPRESS 0x0008
750 class CPDF_ImageSetParam {
751  public:
752   CPDF_ImageSetParam() : pMatteColor(NULL), nQuality(80) {}
753   FX_ARGB* pMatteColor;
754   int32_t nQuality;
755 };
756 class CPDF_Image {
757  public:
758   CPDF_Image(CPDF_Document* pDoc);
759
760   ~CPDF_Image();
761
762   FX_BOOL LoadImageF(CPDF_Stream* pImageStream, FX_BOOL bInline);
763
764   void Release();
765
766   CPDF_Image* Clone();
767
768   FX_BOOL IsInline() { return m_bInline; }
769
770   void SetInlineDict(CPDF_Dictionary* pDict) { m_pInlineDict = pDict; }
771
772   CPDF_Dictionary* GetInlineDict() const { return m_pInlineDict; }
773
774   CPDF_Stream* GetStream() const { return m_pStream; }
775
776   CPDF_Dictionary* GetDict() const {
777     return m_pStream ? m_pStream->GetDict() : NULL;
778   }
779
780   CPDF_Dictionary* GetOC() const { return m_pOC; }
781
782   CPDF_Document* GetDocument() const { return m_pDocument; }
783
784   int32_t GetPixelHeight() const { return m_Height; }
785
786   int32_t GetPixelWidth() const { return m_Width; }
787
788   FX_BOOL IsMask() const { return m_bIsMask; }
789
790   FX_BOOL IsInterpol() const { return m_bInterpolate; }
791
792   CFX_DIBSource* LoadDIBSource(CFX_DIBSource** ppMask = NULL,
793                                FX_DWORD* pMatteColor = NULL,
794                                FX_BOOL bStdCS = FALSE,
795                                FX_DWORD GroupFamily = 0,
796                                FX_BOOL bLoadMask = FALSE) const;
797
798   void SetImage(const CFX_DIBitmap* pDIBitmap,
799                 int32_t iCompress,
800                 IFX_FileWrite* pFileWrite = NULL,
801                 IFX_FileRead* pFileRead = NULL,
802                 const CFX_DIBitmap* pMask = NULL,
803                 const CPDF_ImageSetParam* pParam = NULL);
804
805   void SetJpegImage(uint8_t* pImageData, FX_DWORD size);
806
807   void SetJpegImage(IFX_FileRead* pFile);
808
809   void ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pDIBitmap);
810
811  public:
812   FX_BOOL StartLoadDIBSource(CPDF_Dictionary* pFormResource,
813                              CPDF_Dictionary* pPageResource,
814                              FX_BOOL bStdCS = FALSE,
815                              FX_DWORD GroupFamily = 0,
816                              FX_BOOL bLoadMask = FALSE);
817   FX_BOOL Continue(IFX_Pause* pPause);
818   CFX_DIBSource* DetachBitmap();
819   CFX_DIBSource* DetachMask();
820   CFX_DIBSource* m_pDIBSource;
821   CFX_DIBSource* m_pMask;
822   FX_DWORD m_MatteColor;
823
824  private:
825   CPDF_Stream* m_pStream;
826   FX_BOOL m_bInline;
827   CPDF_Dictionary* m_pInlineDict;
828
829   int32_t m_Height;
830
831   int32_t m_Width;
832
833   FX_BOOL m_bIsMask;
834
835   FX_BOOL m_bInterpolate;
836
837   CPDF_Document* m_pDocument;
838
839   CPDF_Dictionary* m_pOC;
840   CPDF_Dictionary* InitJPEG(uint8_t* pData, FX_DWORD size);
841 };
842
843 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_