| OLD | NEW |
|---|
| (Empty) |
| 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_FPDFAPI_FPDF_RENDER_RENDER_INT_H_ | |
| 8 #define CORE_FPDFAPI_FPDF_RENDER_RENDER_INT_H_ | |
| 9 | |
| 10 #include <map> | |
| 11 #include <memory> | |
| 12 #include <vector> | |
| 13 | |
| 14 #include "core/fpdfapi/fpdf_render/cpdf_renderoptions.h" | |
| 15 #include "core/fpdfapi/page/cpdf_clippath.h" | |
| 16 #include "core/fpdfapi/page/cpdf_countedobject.h" | |
| 17 #include "core/fpdfapi/page/cpdf_graphicstates.h" | |
| 18 #include "core/fpdfapi/parser/cpdf_stream_acc.h" | |
| 19 #include "core/fxge/cfx_fxgedevice.h" | |
| 20 #include "core/fxge/cfx_renderdevice.h" | |
| 21 | |
| 22 class CCodec_Jbig2Context; | |
| 23 class CCodec_ScanlineDecoder; | |
| 24 class CFX_GlyphBitmap; | |
| 25 class CFX_ImageTransformer; | |
| 26 class CFX_PathData; | |
| 27 class CPDF_Color; | |
| 28 class CPDF_Dictionary; | |
| 29 class CPDF_Document; | |
| 30 class CPDF_Font; | |
| 31 class CPDF_FormObject; | |
| 32 class CPDF_ImageCacheEntry; | |
| 33 class CPDF_ImageLoaderHandle; | |
| 34 class CPDF_ImageObject; | |
| 35 class CPDF_ImageRenderer; | |
| 36 class CPDF_Object; | |
| 37 class CPDF_PageObject; | |
| 38 class CPDF_PageObjectHolder; | |
| 39 class CPDF_PageRenderCache; | |
| 40 class CPDF_PathObject; | |
| 41 class CPDF_RenderStatus; | |
| 42 class CPDF_ShadingObject; | |
| 43 class CPDF_ShadingPattern; | |
| 44 class CPDF_Stream; | |
| 45 class CPDF_TilingPattern; | |
| 46 class CPDF_TransferFunc; | |
| 47 class CPDF_Type3Cache; | |
| 48 class CPDF_Type3Glyphs; | |
| 49 class CPDF_Type3Char; | |
| 50 class CPDF_Type3Font; | |
| 51 | |
| 52 FX_BOOL IsAvailableMatrix(const CFX_Matrix& matrix); | |
| 53 | |
| 54 class CPDF_TransferFunc { | |
| 55 public: | |
| 56 explicit CPDF_TransferFunc(CPDF_Document* pDoc); | |
| 57 | |
| 58 FX_COLORREF TranslateColor(FX_COLORREF src) const; | |
| 59 CFX_DIBSource* TranslateImage(const CFX_DIBSource* pSrc, | |
| 60 FX_BOOL bAutoDropSrc); | |
| 61 | |
| 62 CPDF_Document* const m_pPDFDoc; | |
| 63 FX_BOOL m_bIdentity; | |
| 64 uint8_t m_Samples[256 * 3]; | |
| 65 }; | |
| 66 | |
| 67 class CPDF_DocRenderData { | |
| 68 public: | |
| 69 explicit CPDF_DocRenderData(CPDF_Document* pPDFDoc); | |
| 70 ~CPDF_DocRenderData(); | |
| 71 CPDF_Type3Cache* GetCachedType3(CPDF_Type3Font* pFont); | |
| 72 CPDF_TransferFunc* GetTransferFunc(CPDF_Object* pObj); | |
| 73 void Clear(FX_BOOL bRelease = FALSE); | |
| 74 void ReleaseCachedType3(CPDF_Type3Font* pFont); | |
| 75 void ReleaseTransferFunc(CPDF_Object* pObj); | |
| 76 | |
| 77 private: | |
| 78 using CPDF_Type3CacheMap = | |
| 79 std::map<CPDF_Font*, CPDF_CountedObject<CPDF_Type3Cache>*>; | |
| 80 using CPDF_TransferFuncMap = | |
| 81 std::map<CPDF_Object*, CPDF_CountedObject<CPDF_TransferFunc>*>; | |
| 82 | |
| 83 CPDF_Document* m_pPDFDoc; | |
| 84 CPDF_Type3CacheMap m_Type3FaceMap; | |
| 85 CPDF_TransferFuncMap m_TransferFuncMap; | |
| 86 }; | |
| 87 | |
| 88 class CPDF_RenderStatus { | |
| 89 public: | |
| 90 CPDF_RenderStatus(); | |
| 91 ~CPDF_RenderStatus(); | |
| 92 | |
| 93 FX_BOOL Initialize(class CPDF_RenderContext* pContext, | |
| 94 CFX_RenderDevice* pDevice, | |
| 95 const CFX_Matrix* pDeviceMatrix, | |
| 96 const CPDF_PageObject* pStopObj, | |
| 97 const CPDF_RenderStatus* pParentStatus, | |
| 98 const CPDF_GraphicStates* pInitialStates, | |
| 99 const CPDF_RenderOptions* pOptions, | |
| 100 int transparency, | |
| 101 FX_BOOL bDropObjects, | |
| 102 CPDF_Dictionary* pFormResource = nullptr, | |
| 103 FX_BOOL bStdCS = FALSE, | |
| 104 CPDF_Type3Char* pType3Char = nullptr, | |
| 105 FX_ARGB fill_color = 0, | |
| 106 uint32_t GroupFamily = 0, | |
| 107 FX_BOOL bLoadMask = FALSE); | |
| 108 void RenderObjectList(const CPDF_PageObjectHolder* pObjectHolder, | |
| 109 const CFX_Matrix* pObj2Device); | |
| 110 void RenderSingleObject(CPDF_PageObject* pObj, const CFX_Matrix* pObj2Device); | |
| 111 FX_BOOL ContinueSingleObject(CPDF_PageObject* pObj, | |
| 112 const CFX_Matrix* pObj2Device, | |
| 113 IFX_Pause* pPause); | |
| 114 CPDF_RenderContext* GetContext() { return m_pContext; } | |
| 115 | |
| 116 #if defined _SKIA_SUPPORT_ | |
| 117 void DebugVerifyDeviceIsPreMultiplied() const; | |
| 118 #endif | |
| 119 | |
| 120 CPDF_RenderOptions m_Options; | |
| 121 CPDF_Dictionary* m_pFormResource; | |
| 122 CPDF_Dictionary* m_pPageResource; | |
| 123 CFX_ArrayTemplate<CPDF_Type3Font*> m_Type3FontCache; | |
| 124 | |
| 125 protected: | |
| 126 friend class CPDF_ImageRenderer; | |
| 127 friend class CPDF_RenderContext; | |
| 128 | |
| 129 void ProcessClipPath(CPDF_ClipPath ClipPath, const CFX_Matrix* pObj2Device); | |
| 130 void DrawClipPath(CPDF_ClipPath ClipPath, const CFX_Matrix* pObj2Device); | |
| 131 FX_BOOL ProcessTransparency(CPDF_PageObject* PageObj, | |
| 132 const CFX_Matrix* pObj2Device); | |
| 133 void ProcessObjectNoClip(CPDF_PageObject* PageObj, | |
| 134 const CFX_Matrix* pObj2Device); | |
| 135 void DrawObjWithBackground(CPDF_PageObject* pObj, | |
| 136 const CFX_Matrix* pObj2Device); | |
| 137 FX_BOOL DrawObjWithBlend(CPDF_PageObject* pObj, | |
| 138 const CFX_Matrix* pObj2Device); | |
| 139 FX_BOOL ProcessPath(CPDF_PathObject* pPathObj, const CFX_Matrix* pObj2Device); | |
| 140 void ProcessPathPattern(CPDF_PathObject* pPathObj, | |
| 141 const CFX_Matrix* pObj2Device, | |
| 142 int& filltype, | |
| 143 FX_BOOL& bStroke); | |
| 144 void DrawPathWithPattern(CPDF_PathObject* pPathObj, | |
| 145 const CFX_Matrix* pObj2Device, | |
| 146 const CPDF_Color* pColor, | |
| 147 FX_BOOL bStroke); | |
| 148 void DrawTilingPattern(CPDF_TilingPattern* pPattern, | |
| 149 CPDF_PageObject* pPageObj, | |
| 150 const CFX_Matrix* pObj2Device, | |
| 151 FX_BOOL bStroke); | |
| 152 void DrawShadingPattern(CPDF_ShadingPattern* pPattern, | |
| 153 const CPDF_PageObject* pPageObj, | |
| 154 const CFX_Matrix* pObj2Device, | |
| 155 FX_BOOL bStroke); | |
| 156 FX_BOOL SelectClipPath(const CPDF_PathObject* pPathObj, | |
| 157 const CFX_Matrix* pObj2Device, | |
| 158 FX_BOOL bStroke); | |
| 159 FX_BOOL ProcessImage(CPDF_ImageObject* pImageObj, | |
| 160 const CFX_Matrix* pObj2Device); | |
| 161 FX_BOOL OutputBitmapAlpha(CPDF_ImageObject* pImageObj, | |
| 162 const CFX_Matrix* pImage2Device); | |
| 163 FX_BOOL OutputImage(CPDF_ImageObject* pImageObj, | |
| 164 const CFX_Matrix* pImage2Device); | |
| 165 FX_BOOL OutputDIBSource(const CFX_DIBSource* pOutputBitmap, | |
| 166 FX_ARGB fill_argb, | |
| 167 int bitmap_alpha, | |
| 168 const CFX_Matrix* pImage2Device, | |
| 169 CPDF_ImageCacheEntry* pImageCache, | |
| 170 uint32_t flags); | |
| 171 void CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, | |
| 172 int left, | |
| 173 int top, | |
| 174 FX_ARGB mask_argb, | |
| 175 int bitmap_alpha, | |
| 176 int blend_mode, | |
| 177 int bIsolated); | |
| 178 void ProcessShading(const CPDF_ShadingObject* pShadingObj, | |
| 179 const CFX_Matrix* pObj2Device); | |
| 180 void DrawShading(CPDF_ShadingPattern* pPattern, | |
| 181 CFX_Matrix* pMatrix, | |
| 182 FX_RECT& clip_rect, | |
| 183 int alpha, | |
| 184 FX_BOOL bAlphaMode); | |
| 185 FX_BOOL ProcessType3Text(CPDF_TextObject* textobj, | |
| 186 const CFX_Matrix* pObj2Device); | |
| 187 FX_BOOL ProcessText(CPDF_TextObject* textobj, | |
| 188 const CFX_Matrix* pObj2Device, | |
| 189 CFX_PathData* pClippingPath); | |
| 190 void DrawTextPathWithPattern(const CPDF_TextObject* textobj, | |
| 191 const CFX_Matrix* pObj2Device, | |
| 192 CPDF_Font* pFont, | |
| 193 FX_FLOAT font_size, | |
| 194 const CFX_Matrix* pTextMatrix, | |
| 195 FX_BOOL bFill, | |
| 196 FX_BOOL bStroke); | |
| 197 FX_BOOL ProcessForm(const CPDF_FormObject* pFormObj, | |
| 198 const CFX_Matrix* pObj2Device); | |
| 199 CFX_DIBitmap* GetBackdrop(const CPDF_PageObject* pObj, | |
| 200 const FX_RECT& rect, | |
| 201 int& left, | |
| 202 int& top, | |
| 203 FX_BOOL bBackAlphaRequired); | |
| 204 CFX_DIBitmap* LoadSMask(CPDF_Dictionary* pSMaskDict, | |
| 205 FX_RECT* pClipRect, | |
| 206 const CFX_Matrix* pMatrix); | |
| 207 void Init(CPDF_RenderContext* pParent); | |
| 208 static class CPDF_Type3Cache* GetCachedType3(CPDF_Type3Font* pFont); | |
| 209 static CPDF_GraphicStates* CloneObjStates(const CPDF_GraphicStates* pPathObj, | |
| 210 FX_BOOL bStroke); | |
| 211 CPDF_TransferFunc* GetTransferFunc(CPDF_Object* pObject) const; | |
| 212 FX_ARGB GetFillArgb(CPDF_PageObject* pObj, FX_BOOL bType3 = FALSE) const; | |
| 213 FX_ARGB GetStrokeArgb(CPDF_PageObject* pObj) const; | |
| 214 FX_BOOL GetObjectClippedRect(const CPDF_PageObject* pObj, | |
| 215 const CFX_Matrix* pObj2Device, | |
| 216 FX_BOOL bLogical, | |
| 217 FX_RECT& rect) const; | |
| 218 void GetScaledMatrix(CFX_Matrix& matrix) const; | |
| 219 | |
| 220 static const int kRenderMaxRecursionDepth = 64; | |
| 221 static int s_CurrentRecursionDepth; | |
| 222 | |
| 223 CPDF_RenderContext* m_pContext; | |
| 224 FX_BOOL m_bStopped; | |
| 225 CFX_RenderDevice* m_pDevice; | |
| 226 CFX_Matrix m_DeviceMatrix; | |
| 227 CPDF_ClipPath m_LastClipPath; | |
| 228 const CPDF_PageObject* m_pCurObj; | |
| 229 const CPDF_PageObject* m_pStopObj; | |
| 230 CPDF_GraphicStates m_InitialStates; | |
| 231 int m_HalftoneLimit; | |
| 232 std::unique_ptr<CPDF_ImageRenderer> m_pImageRenderer; | |
| 233 FX_BOOL m_bPrint; | |
| 234 int m_Transparency; | |
| 235 FX_BOOL m_bDropObjects; | |
| 236 FX_BOOL m_bStdCS; | |
| 237 uint32_t m_GroupFamily; | |
| 238 FX_BOOL m_bLoadMask; | |
| 239 CPDF_Type3Char* m_pType3Char; | |
| 240 FX_ARGB m_T3FillColor; | |
| 241 int m_curBlend; | |
| 242 }; | |
| 243 | |
| 244 class CPDF_ImageLoader { | |
| 245 public: | |
| 246 CPDF_ImageLoader() | |
| 247 : m_pBitmap(nullptr), | |
| 248 m_pMask(nullptr), | |
| 249 m_MatteColor(0), | |
| 250 m_bCached(FALSE), | |
| 251 m_nDownsampleWidth(0), | |
| 252 m_nDownsampleHeight(0) {} | |
| 253 ~CPDF_ImageLoader(); | |
| 254 | |
| 255 FX_BOOL Start(const CPDF_ImageObject* pImage, | |
| 256 CPDF_PageRenderCache* pCache, | |
| 257 std::unique_ptr<CPDF_ImageLoaderHandle>* pLoadHandle, | |
| 258 FX_BOOL bStdCS = FALSE, | |
| 259 uint32_t GroupFamily = 0, | |
| 260 FX_BOOL bLoadMask = FALSE, | |
| 261 CPDF_RenderStatus* pRenderStatus = nullptr, | |
| 262 int32_t nDownsampleWidth = 0, | |
| 263 int32_t nDownsampleHeight = 0); | |
| 264 FX_BOOL Continue(CPDF_ImageLoaderHandle* LoadHandle, IFX_Pause* pPause); | |
| 265 | |
| 266 CFX_DIBSource* m_pBitmap; | |
| 267 CFX_DIBSource* m_pMask; | |
| 268 uint32_t m_MatteColor; | |
| 269 FX_BOOL m_bCached; | |
| 270 | |
| 271 protected: | |
| 272 int32_t m_nDownsampleWidth; | |
| 273 int32_t m_nDownsampleHeight; | |
| 274 }; | |
| 275 | |
| 276 class CPDF_ImageLoaderHandle { | |
| 277 public: | |
| 278 CPDF_ImageLoaderHandle(); | |
| 279 ~CPDF_ImageLoaderHandle(); | |
| 280 | |
| 281 FX_BOOL Start(CPDF_ImageLoader* pImageLoader, | |
| 282 const CPDF_ImageObject* pImage, | |
| 283 CPDF_PageRenderCache* pCache, | |
| 284 FX_BOOL bStdCS = FALSE, | |
| 285 uint32_t GroupFamily = 0, | |
| 286 FX_BOOL bLoadMask = FALSE, | |
| 287 CPDF_RenderStatus* pRenderStatus = nullptr, | |
| 288 int32_t nDownsampleWidth = 0, | |
| 289 int32_t nDownsampleHeight = 0); | |
| 290 FX_BOOL Continue(IFX_Pause* pPause); | |
| 291 | |
| 292 protected: | |
| 293 void HandleFailure(); | |
| 294 | |
| 295 CPDF_ImageLoader* m_pImageLoader; | |
| 296 CPDF_PageRenderCache* m_pCache; | |
| 297 CPDF_ImageObject* m_pImage; | |
| 298 int32_t m_nDownsampleWidth; | |
| 299 int32_t m_nDownsampleHeight; | |
| 300 }; | |
| 301 | |
| 302 class CPDF_ImageRenderer { | |
| 303 public: | |
| 304 CPDF_ImageRenderer(); | |
| 305 ~CPDF_ImageRenderer(); | |
| 306 | |
| 307 FX_BOOL Start(CPDF_RenderStatus* pStatus, | |
| 308 CPDF_PageObject* pObj, | |
| 309 const CFX_Matrix* pObj2Device, | |
| 310 FX_BOOL bStdCS, | |
| 311 int blendType = FXDIB_BLEND_NORMAL); | |
| 312 FX_BOOL Continue(IFX_Pause* pPause); | |
| 313 | |
| 314 FX_BOOL Start(CPDF_RenderStatus* pStatus, | |
| 315 const CFX_DIBSource* pDIBSource, | |
| 316 FX_ARGB bitmap_argb, | |
| 317 int bitmap_alpha, | |
| 318 const CFX_Matrix* pImage2Device, | |
| 319 uint32_t flags, | |
| 320 FX_BOOL bStdCS, | |
| 321 int blendType = FXDIB_BLEND_NORMAL); | |
| 322 | |
| 323 FX_BOOL m_Result; | |
| 324 | |
| 325 protected: | |
| 326 FX_BOOL StartBitmapAlpha(); | |
| 327 FX_BOOL StartDIBSource(); | |
| 328 FX_BOOL StartRenderDIBSource(); | |
| 329 FX_BOOL StartLoadDIBSource(); | |
| 330 FX_BOOL DrawMaskedImage(); | |
| 331 FX_BOOL DrawPatternImage(const CFX_Matrix* pObj2Device); | |
| 332 | |
| 333 CPDF_RenderStatus* m_pRenderStatus; | |
| 334 CPDF_ImageObject* m_pImageObject; | |
| 335 int m_Status; | |
| 336 const CFX_Matrix* m_pObj2Device; | |
| 337 CFX_Matrix m_ImageMatrix; | |
| 338 CPDF_ImageLoader m_Loader; | |
| 339 const CFX_DIBSource* m_pDIBSource; | |
| 340 std::unique_ptr<CFX_DIBitmap> m_pClone; | |
| 341 int m_BitmapAlpha; | |
| 342 FX_BOOL m_bPatternColor; | |
| 343 CPDF_Pattern* m_pPattern; | |
| 344 FX_ARGB m_FillArgb; | |
| 345 uint32_t m_Flags; | |
| 346 std::unique_ptr<CFX_ImageTransformer> m_pTransformer; | |
| 347 void* m_DeviceHandle; | |
| 348 std::unique_ptr<CPDF_ImageLoaderHandle> m_LoadHandle; | |
| 349 FX_BOOL m_bStdCS; | |
| 350 int m_BlendType; | |
| 351 }; | |
| 352 | |
| 353 class CPDF_ScaledRenderBuffer { | |
| 354 public: | |
| 355 CPDF_ScaledRenderBuffer(); | |
| 356 ~CPDF_ScaledRenderBuffer(); | |
| 357 | |
| 358 FX_BOOL Initialize(CPDF_RenderContext* pContext, | |
| 359 CFX_RenderDevice* pDevice, | |
| 360 const FX_RECT& pRect, | |
| 361 const CPDF_PageObject* pObj, | |
| 362 const CPDF_RenderOptions* pOptions = nullptr, | |
| 363 int max_dpi = 0); | |
| 364 CFX_RenderDevice* GetDevice() { | |
| 365 return m_pBitmapDevice ? m_pBitmapDevice.get() : m_pDevice; | |
| 366 } | |
| 367 CFX_Matrix* GetMatrix() { return &m_Matrix; } | |
| 368 void OutputToDevice(); | |
| 369 | |
| 370 private: | |
| 371 CFX_RenderDevice* m_pDevice; | |
| 372 CPDF_RenderContext* m_pContext; | |
| 373 FX_RECT m_Rect; | |
| 374 const CPDF_PageObject* m_pObject; | |
| 375 std::unique_ptr<CFX_FxgeDevice> m_pBitmapDevice; | |
| 376 CFX_Matrix m_Matrix; | |
| 377 }; | |
| 378 | |
| 379 class CPDF_DeviceBuffer { | |
| 380 public: | |
| 381 CPDF_DeviceBuffer(); | |
| 382 ~CPDF_DeviceBuffer(); | |
| 383 FX_BOOL Initialize(CPDF_RenderContext* pContext, | |
| 384 CFX_RenderDevice* pDevice, | |
| 385 FX_RECT* pRect, | |
| 386 const CPDF_PageObject* pObj, | |
| 387 int max_dpi = 0); | |
| 388 void OutputToDevice(); | |
| 389 CFX_DIBitmap* GetBitmap() const { return m_pBitmap.get(); } | |
| 390 const CFX_Matrix* GetMatrix() const { return &m_Matrix; } | |
| 391 | |
| 392 private: | |
| 393 CFX_RenderDevice* m_pDevice; | |
| 394 CPDF_RenderContext* m_pContext; | |
| 395 FX_RECT m_Rect; | |
| 396 const CPDF_PageObject* m_pObject; | |
| 397 std::unique_ptr<CFX_DIBitmap> m_pBitmap; | |
| 398 CFX_Matrix m_Matrix; | |
| 399 }; | |
| 400 | |
| 401 class CPDF_ImageCacheEntry { | |
| 402 public: | |
| 403 CPDF_ImageCacheEntry(CPDF_Document* pDoc, CPDF_Stream* pStream); | |
| 404 ~CPDF_ImageCacheEntry(); | |
| 405 | |
| 406 void Reset(const CFX_DIBitmap* pBitmap); | |
| 407 FX_BOOL GetCachedBitmap(CFX_DIBSource*& pBitmap, | |
| 408 CFX_DIBSource*& pMask, | |
| 409 uint32_t& MatteColor, | |
| 410 CPDF_Dictionary* pPageResources, | |
| 411 FX_BOOL bStdCS = FALSE, | |
| 412 uint32_t GroupFamily = 0, | |
| 413 FX_BOOL bLoadMask = FALSE, | |
| 414 CPDF_RenderStatus* pRenderStatus = nullptr, | |
| 415 int32_t downsampleWidth = 0, | |
| 416 int32_t downsampleHeight = 0); | |
| 417 uint32_t EstimateSize() const { return m_dwCacheSize; } | |
| 418 uint32_t GetTimeCount() const { return m_dwTimeCount; } | |
| 419 CPDF_Stream* GetStream() const { return m_pStream; } | |
| 420 void SetTimeCount(uint32_t dwTimeCount) { m_dwTimeCount = dwTimeCount; } | |
| 421 int m_dwTimeCount; | |
| 422 | |
| 423 public: | |
| 424 int StartGetCachedBitmap(CPDF_Dictionary* pFormResources, | |
| 425 CPDF_Dictionary* pPageResources, | |
| 426 FX_BOOL bStdCS = FALSE, | |
| 427 uint32_t GroupFamily = 0, | |
| 428 FX_BOOL bLoadMask = FALSE, | |
| 429 CPDF_RenderStatus* pRenderStatus = nullptr, | |
| 430 int32_t downsampleWidth = 0, | |
| 431 int32_t downsampleHeight = 0); | |
| 432 int Continue(IFX_Pause* pPause); | |
| 433 CFX_DIBSource* DetachBitmap(); | |
| 434 CFX_DIBSource* DetachMask(); | |
| 435 CFX_DIBSource* m_pCurBitmap; | |
| 436 CFX_DIBSource* m_pCurMask; | |
| 437 uint32_t m_MatteColor; | |
| 438 CPDF_RenderStatus* m_pRenderStatus; | |
| 439 | |
| 440 protected: | |
| 441 void ContinueGetCachedBitmap(); | |
| 442 | |
| 443 CPDF_Document* m_pDocument; | |
| 444 CPDF_Stream* m_pStream; | |
| 445 CFX_DIBSource* m_pCachedBitmap; | |
| 446 CFX_DIBSource* m_pCachedMask; | |
| 447 uint32_t m_dwCacheSize; | |
| 448 void CalcSize(); | |
| 449 }; | |
| 450 typedef struct { | |
| 451 FX_FLOAT m_DecodeMin; | |
| 452 FX_FLOAT m_DecodeStep; | |
| 453 int m_ColorKeyMin; | |
| 454 int m_ColorKeyMax; | |
| 455 } DIB_COMP_DATA; | |
| 456 | |
| 457 class CPDF_DIBSource : public CFX_DIBSource { | |
| 458 public: | |
| 459 CPDF_DIBSource(); | |
| 460 ~CPDF_DIBSource() override; | |
| 461 | |
| 462 FX_BOOL Load(CPDF_Document* pDoc, | |
| 463 const CPDF_Stream* pStream, | |
| 464 CPDF_DIBSource** ppMask, | |
| 465 uint32_t* pMatteColor, | |
| 466 CPDF_Dictionary* pFormResources, | |
| 467 CPDF_Dictionary* pPageResources, | |
| 468 FX_BOOL bStdCS = FALSE, | |
| 469 uint32_t GroupFamily = 0, | |
| 470 FX_BOOL bLoadMask = FALSE); | |
| 471 | |
| 472 // CFX_DIBSource | |
| 473 FX_BOOL SkipToScanline(int line, IFX_Pause* pPause) const override; | |
| 474 uint8_t* GetBuffer() const override; | |
| 475 const uint8_t* GetScanline(int line) const override; | |
| 476 void DownSampleScanline(int line, | |
| 477 uint8_t* dest_scan, | |
| 478 int dest_bpp, | |
| 479 int dest_width, | |
| 480 FX_BOOL bFlipX, | |
| 481 int clip_left, | |
| 482 int clip_width) const override; | |
| 483 | |
| 484 CFX_DIBitmap* GetBitmap() const; | |
| 485 void ReleaseBitmap(CFX_DIBitmap* pBitmap) const; | |
| 486 uint32_t GetMatteColor() const { return m_MatteColor; } | |
| 487 | |
| 488 int StartLoadDIBSource(CPDF_Document* pDoc, | |
| 489 const CPDF_Stream* pStream, | |
| 490 FX_BOOL bHasMask, | |
| 491 CPDF_Dictionary* pFormResources, | |
| 492 CPDF_Dictionary* pPageResources, | |
| 493 FX_BOOL bStdCS = FALSE, | |
| 494 uint32_t GroupFamily = 0, | |
| 495 FX_BOOL bLoadMask = FALSE); | |
| 496 int ContinueLoadDIBSource(IFX_Pause* pPause); | |
| 497 int StratLoadMask(); | |
| 498 int StartLoadMaskDIB(); | |
| 499 int ContinueLoadMaskDIB(IFX_Pause* pPause); | |
| 500 int ContinueToLoadMask(); | |
| 501 CPDF_DIBSource* DetachMask(); | |
| 502 | |
| 503 private: | |
| 504 bool LoadColorInfo(const CPDF_Dictionary* pFormResources, | |
| 505 const CPDF_Dictionary* pPageResources); | |
| 506 DIB_COMP_DATA* GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode, | |
| 507 FX_BOOL& bColorKey); | |
| 508 CPDF_DIBSource* LoadMask(uint32_t& MatteColor); | |
| 509 CPDF_DIBSource* LoadMaskDIB(CPDF_Stream* pMask); | |
| 510 void LoadJpxBitmap(); | |
| 511 void LoadPalette(); | |
| 512 int CreateDecoder(); | |
| 513 void TranslateScanline24bpp(uint8_t* dest_scan, | |
| 514 const uint8_t* src_scan) const; | |
| 515 void ValidateDictParam(); | |
| 516 void DownSampleScanline1Bit(int orig_Bpp, | |
| 517 int dest_Bpp, | |
| 518 uint32_t src_width, | |
| 519 const uint8_t* pSrcLine, | |
| 520 uint8_t* dest_scan, | |
| 521 int dest_width, | |
| 522 FX_BOOL bFlipX, | |
| 523 int clip_left, | |
| 524 int clip_width) const; | |
| 525 void DownSampleScanline8Bit(int orig_Bpp, | |
| 526 int dest_Bpp, | |
| 527 uint32_t src_width, | |
| 528 const uint8_t* pSrcLine, | |
| 529 uint8_t* dest_scan, | |
| 530 int dest_width, | |
| 531 FX_BOOL bFlipX, | |
| 532 int clip_left, | |
| 533 int clip_width) const; | |
| 534 void DownSampleScanline32Bit(int orig_Bpp, | |
| 535 int dest_Bpp, | |
| 536 uint32_t src_width, | |
| 537 const uint8_t* pSrcLine, | |
| 538 uint8_t* dest_scan, | |
| 539 int dest_width, | |
| 540 FX_BOOL bFlipX, | |
| 541 int clip_left, | |
| 542 int clip_width) const; | |
| 543 FX_BOOL TransMask() const; | |
| 544 | |
| 545 CPDF_Document* m_pDocument; | |
| 546 const CPDF_Stream* m_pStream; | |
| 547 std::unique_ptr<CPDF_StreamAcc> m_pStreamAcc; | |
| 548 const CPDF_Dictionary* m_pDict; | |
| 549 CPDF_ColorSpace* m_pColorSpace; | |
| 550 uint32_t m_Family; | |
| 551 uint32_t m_bpc; | |
| 552 uint32_t m_bpc_orig; | |
| 553 uint32_t m_nComponents; | |
| 554 uint32_t m_GroupFamily; | |
| 555 uint32_t m_MatteColor; | |
| 556 FX_BOOL m_bLoadMask; | |
| 557 FX_BOOL m_bDefaultDecode; | |
| 558 FX_BOOL m_bImageMask; | |
| 559 FX_BOOL m_bDoBpcCheck; | |
| 560 FX_BOOL m_bColorKey; | |
| 561 FX_BOOL m_bHasMask; | |
| 562 FX_BOOL m_bStdCS; | |
| 563 DIB_COMP_DATA* m_pCompData; | |
| 564 uint8_t* m_pLineBuf; | |
| 565 uint8_t* m_pMaskedLine; | |
| 566 std::unique_ptr<CFX_DIBitmap> m_pCachedBitmap; | |
| 567 std::unique_ptr<CCodec_ScanlineDecoder> m_pDecoder; | |
| 568 CPDF_DIBSource* m_pMask; | |
| 569 std::unique_ptr<CPDF_StreamAcc> m_pGlobalStream; | |
| 570 std::unique_ptr<CCodec_Jbig2Context> m_pJbig2Context; | |
| 571 CPDF_Stream* m_pMaskStream; | |
| 572 int m_Status; | |
| 573 }; | |
| 574 | |
| 575 #define FPDF_HUGE_IMAGE_SIZE 60000000 | |
| 576 class CPDF_DIBTransferFunc : public CFX_FilteredDIB { | |
| 577 public: | |
| 578 explicit CPDF_DIBTransferFunc(const CPDF_TransferFunc* pTransferFunc); | |
| 579 ~CPDF_DIBTransferFunc() override; | |
| 580 | |
| 581 // CFX_FilteredDIB | |
| 582 FXDIB_Format GetDestFormat() override; | |
| 583 FX_ARGB* GetDestPalette() override; | |
| 584 void TranslateScanline(const uint8_t* src_buf, | |
| 585 std::vector<uint8_t>* dest_buf) const override; | |
| 586 void TranslateDownSamples(uint8_t* dest_buf, | |
| 587 const uint8_t* src_buf, | |
| 588 int pixels, | |
| 589 int Bpp) const override; | |
| 590 | |
| 591 const uint8_t* m_RampR; | |
| 592 const uint8_t* m_RampG; | |
| 593 const uint8_t* m_RampB; | |
| 594 }; | |
| 595 | |
| 596 #endif // CORE_FPDFAPI_FPDF_RENDER_RENDER_INT_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2393593002:
Move core/fpdfapi/fpdf_render to core/fpdfapi/render (Closed)
