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