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