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