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_