Reapply Foxit's libopenjpeg modifications.
[pdfium.git] / core / src / fpdfapi / fpdf_render / fpdf_render_image.cpp
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 #include "../../../include/fpdfapi/fpdf_module.h"
8 #include "../../../include/fpdfapi/fpdf_pageobj.h"
9 #include "../../../include/fpdfapi/fpdf_render.h"
10 #include "../../../include/fxcodec/fx_codec.h"
11 #include "../../../include/fxcrt/fx_safe_types.h"
12 #include "../../../include/fxge/fx_ge.h"
13 #include "../fpdf_page/pageint.h"
14 #include "render_int.h"
15
16 FX_BOOL CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj,
17                                         const CFX_AffineMatrix* pObj2Device) {
18   CPDF_ImageRenderer render;
19   if (render.Start(this, pImageObj, pObj2Device, m_bStdCS, m_curBlend)) {
20     render.Continue(NULL);
21   }
22   return render.m_Result;
23 }
24 void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
25                                           int left,
26                                           int top,
27                                           FX_ARGB mask_argb,
28                                           int bitmap_alpha,
29                                           int blend_mode,
30                                           int Transparency) {
31   if (pDIBitmap == NULL) {
32     return;
33   }
34   FX_BOOL bIsolated = Transparency & PDFTRANS_ISOLATED;
35   FX_BOOL bGroup = Transparency & PDFTRANS_GROUP;
36   if (blend_mode == FXDIB_BLEND_NORMAL) {
37     if (!pDIBitmap->IsAlphaMask()) {
38       if (bitmap_alpha < 255) {
39         pDIBitmap->MultiplyAlpha(bitmap_alpha);
40       }
41       if (m_pDevice->SetDIBits(pDIBitmap, left, top)) {
42         return;
43       }
44     } else {
45       FX_DWORD fill_argb = m_Options.TranslateColor(mask_argb);
46       if (bitmap_alpha < 255) {
47         ((uint8_t*)&fill_argb)[3] =
48             ((uint8_t*)&fill_argb)[3] * bitmap_alpha / 255;
49       }
50       if (m_pDevice->SetBitMask(pDIBitmap, left, top, fill_argb)) {
51         return;
52       }
53     }
54   }
55   FX_BOOL bBackAlphaRequired = blend_mode && bIsolated && !m_bDropObjects;
56   FX_BOOL bGetBackGround =
57       ((m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT)) ||
58       (!(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT) &&
59        (m_pDevice->GetRenderCaps() & FXRC_GET_BITS) && !bBackAlphaRequired);
60   if (bGetBackGround) {
61     if (bIsolated || !bGroup) {
62       if (pDIBitmap->IsAlphaMask()) {
63         return;
64       }
65       m_pDevice->SetDIBits(pDIBitmap, left, top, blend_mode);
66     } else {
67       FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
68                    top + pDIBitmap->GetHeight());
69       rect.Intersect(m_pDevice->GetClipBox());
70       CFX_DIBitmap* pClone = NULL;
71       FX_BOOL bClone = FALSE;
72       if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) {
73         bClone = TRUE;
74         pClone = m_pDevice->GetBackDrop()->Clone(&rect);
75         CFX_DIBitmap* pForeBitmap = m_pDevice->GetBitmap();
76         pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
77                                 pForeBitmap, rect.left, rect.top);
78         left = left >= 0 ? 0 : left;
79         top = top >= 0 ? 0 : top;
80         if (!pDIBitmap->IsAlphaMask())
81           pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(),
82                                   pDIBitmap, left, top, blend_mode);
83         else
84           pClone->CompositeMask(0, 0, pClone->GetWidth(), pClone->GetHeight(),
85                                 pDIBitmap, mask_argb, left, top, blend_mode);
86       } else {
87         pClone = pDIBitmap;
88       }
89       if (m_pDevice->GetBackDrop()) {
90         m_pDevice->SetDIBits(pClone, rect.left, rect.top);
91       } else {
92         if (pDIBitmap->IsAlphaMask()) {
93           return;
94         }
95         m_pDevice->SetDIBits(pDIBitmap, rect.left, rect.top, blend_mode);
96       }
97       if (bClone) {
98         delete pClone;
99       }
100     }
101     return;
102   }
103   int back_left, back_top;
104   FX_RECT rect(left, top, left + pDIBitmap->GetWidth(),
105                top + pDIBitmap->GetHeight());
106   CFX_DIBitmap* pBackdrop =
107       GetBackdrop(m_pCurObj, rect, back_left, back_top,
108                   blend_mode > FXDIB_BLEND_NORMAL && bIsolated);
109   if (!pBackdrop) {
110     return;
111   }
112   if (!pDIBitmap->IsAlphaMask())
113     pBackdrop->CompositeBitmap(left - back_left, top - back_top,
114                                pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
115                                pDIBitmap, 0, 0, blend_mode);
116   else
117     pBackdrop->CompositeMask(left - back_left, top - back_top,
118                              pDIBitmap->GetWidth(), pDIBitmap->GetHeight(),
119                              pDIBitmap, mask_argb, 0, 0, blend_mode);
120   CFX_DIBitmap* pBackdrop1 = new CFX_DIBitmap;
121   pBackdrop1->Create(pBackdrop->GetWidth(), pBackdrop->GetHeight(),
122                      FXDIB_Rgb32);
123   pBackdrop1->Clear((FX_DWORD)-1);
124   pBackdrop1->CompositeBitmap(0, 0, pBackdrop->GetWidth(),
125                               pBackdrop->GetHeight(), pBackdrop, 0, 0);
126   delete pBackdrop;
127   pBackdrop = pBackdrop1;
128   m_pDevice->SetDIBits(pBackdrop, back_left, back_top);
129   delete pBackdrop;
130 }
131 FX_COLORREF CPDF_TransferFunc::TranslateColor(FX_COLORREF rgb) {
132   return FXSYS_RGB(m_Samples[FXSYS_GetRValue(rgb)],
133                    m_Samples[256 + FXSYS_GetGValue(rgb)],
134                    m_Samples[512 + FXSYS_GetBValue(rgb)]);
135 }
136 CFX_DIBSource* CPDF_TransferFunc::TranslateImage(const CFX_DIBSource* pSrc,
137                                                  FX_BOOL bAutoDropSrc) {
138   CPDF_DIBTransferFunc* pDest = new CPDF_DIBTransferFunc(this);
139   pDest->LoadSrc(pSrc, bAutoDropSrc);
140   return pDest;
141 }
142
143 CPDF_DIBTransferFunc::~CPDF_DIBTransferFunc() {
144 }
145
146 FXDIB_Format CPDF_DIBTransferFunc::GetDestFormat() {
147   if (m_pSrc->IsAlphaMask()) {
148     return FXDIB_8bppMask;
149   }
150 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
151   return (m_pSrc->HasAlpha()) ? FXDIB_Argb : FXDIB_Rgb32;
152 #else
153   return (m_pSrc->HasAlpha()) ? FXDIB_Argb : FXDIB_Rgb;
154 #endif
155 }
156 CPDF_DIBTransferFunc::CPDF_DIBTransferFunc(
157     const CPDF_TransferFunc* pTransferFunc) {
158   m_RampR = pTransferFunc->m_Samples;
159   m_RampG = &pTransferFunc->m_Samples[256];
160   m_RampB = &pTransferFunc->m_Samples[512];
161 }
162 void CPDF_DIBTransferFunc::TranslateScanline(uint8_t* dest_buf,
163                                              const uint8_t* src_buf) const {
164   int i;
165   FX_BOOL bSkip = FALSE;
166   switch (m_pSrc->GetFormat()) {
167     case FXDIB_1bppRgb: {
168       int r0 = m_RampR[0], g0 = m_RampG[0], b0 = m_RampB[0];
169       int r1 = m_RampR[255], g1 = m_RampG[255], b1 = m_RampB[255];
170       for (i = 0; i < m_Width; i++) {
171         if (src_buf[i / 8] & (1 << (7 - i % 8))) {
172           *dest_buf++ = b1;
173           *dest_buf++ = g1;
174           *dest_buf++ = r1;
175         } else {
176           *dest_buf++ = b0;
177           *dest_buf++ = g0;
178           *dest_buf++ = r0;
179         }
180 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
181         dest_buf++;
182 #endif
183       }
184       break;
185     }
186     case FXDIB_1bppMask: {
187       int m0 = m_RampR[0], m1 = m_RampR[255];
188       for (i = 0; i < m_Width; i++) {
189         if (src_buf[i / 8] & (1 << (7 - i % 8))) {
190           *dest_buf++ = m1;
191         } else {
192           *dest_buf++ = m0;
193         }
194       }
195       break;
196     }
197     case FXDIB_8bppRgb: {
198       FX_ARGB* pPal = m_pSrc->GetPalette();
199       for (i = 0; i < m_Width; i++) {
200         if (pPal) {
201           FX_ARGB src_argb = pPal[*src_buf];
202           *dest_buf++ = m_RampB[FXARGB_R(src_argb)];
203           *dest_buf++ = m_RampG[FXARGB_G(src_argb)];
204           *dest_buf++ = m_RampR[FXARGB_B(src_argb)];
205         } else {
206           FX_DWORD src_byte = *src_buf;
207           *dest_buf++ = m_RampB[src_byte];
208           *dest_buf++ = m_RampG[src_byte];
209           *dest_buf++ = m_RampR[src_byte];
210         }
211         src_buf++;
212 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
213         dest_buf++;
214 #endif
215       }
216       break;
217     }
218     case FXDIB_8bppMask:
219       for (i = 0; i < m_Width; i++) {
220         *dest_buf++ = m_RampR[*(src_buf++)];
221       }
222       break;
223     case FXDIB_Rgb:
224       for (i = 0; i < m_Width; i++) {
225         *dest_buf++ = m_RampB[*(src_buf++)];
226         *dest_buf++ = m_RampG[*(src_buf++)];
227         *dest_buf++ = m_RampR[*(src_buf++)];
228 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
229         dest_buf++;
230 #endif
231       }
232       break;
233     case FXDIB_Rgb32:
234       bSkip = TRUE;
235     case FXDIB_Argb:
236       for (i = 0; i < m_Width; i++) {
237         *dest_buf++ = m_RampB[*(src_buf++)];
238         *dest_buf++ = m_RampG[*(src_buf++)];
239         *dest_buf++ = m_RampR[*(src_buf++)];
240         if (!bSkip) {
241           *dest_buf++ = *src_buf;
242         }
243 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
244         else {
245           dest_buf++;
246         }
247 #endif
248         src_buf++;
249       }
250       break;
251     default:
252       break;
253   }
254 }
255 void CPDF_DIBTransferFunc::TranslateDownSamples(uint8_t* dest_buf,
256                                                 const uint8_t* src_buf,
257                                                 int pixels,
258                                                 int Bpp) const {
259   if (Bpp == 8) {
260     for (int i = 0; i < pixels; i++) {
261       *dest_buf++ = m_RampR[*(src_buf++)];
262     }
263   } else if (Bpp == 24) {
264     for (int i = 0; i < pixels; i++) {
265       *dest_buf++ = m_RampB[*(src_buf++)];
266       *dest_buf++ = m_RampG[*(src_buf++)];
267       *dest_buf++ = m_RampR[*(src_buf++)];
268     }
269   } else {
270 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
271     if (!m_pSrc->HasAlpha()) {
272       for (int i = 0; i < pixels; i++) {
273         *dest_buf++ = m_RampB[*(src_buf++)];
274         *dest_buf++ = m_RampG[*(src_buf++)];
275         *dest_buf++ = m_RampR[*(src_buf++)];
276         dest_buf++;
277         src_buf++;
278       }
279     } else
280 #endif
281       for (int i = 0; i < pixels; i++) {
282         *dest_buf++ = m_RampB[*(src_buf++)];
283         *dest_buf++ = m_RampG[*(src_buf++)];
284         *dest_buf++ = m_RampR[*(src_buf++)];
285         *dest_buf++ = *(src_buf++);
286       }
287   }
288 }
289 static FX_BOOL _IsSupported(CPDF_ColorSpace* pCS) {
290   if (pCS->GetFamily() == PDFCS_DEVICERGB ||
291       pCS->GetFamily() == PDFCS_DEVICEGRAY ||
292       pCS->GetFamily() == PDFCS_DEVICECMYK ||
293       pCS->GetFamily() == PDFCS_CALGRAY || pCS->GetFamily() == PDFCS_CALRGB) {
294     return TRUE;
295   }
296   if (pCS->GetFamily() == PDFCS_INDEXED && _IsSupported(pCS->GetBaseCS())) {
297     return TRUE;
298   }
299   return FALSE;
300 }
301 CPDF_ImageRenderer::CPDF_ImageRenderer() {
302   m_pRenderStatus = NULL;
303   m_pImageObject = NULL;
304   m_Result = TRUE;
305   m_Status = 0;
306   m_pQuickStretcher = NULL;
307   m_pTransformer = NULL;
308   m_DeviceHandle = NULL;
309   m_LoadHandle = NULL;
310   m_pClone = NULL;
311   m_bStdCS = FALSE;
312   m_bPatternColor = FALSE;
313   m_BlendType = FXDIB_BLEND_NORMAL;
314   m_pPattern = NULL;
315   m_pObj2Device = NULL;
316 }
317 CPDF_ImageRenderer::~CPDF_ImageRenderer() {
318   delete m_pQuickStretcher;
319   delete m_pTransformer;
320   if (m_DeviceHandle) {
321     m_pRenderStatus->m_pDevice->CancelDIBits(m_DeviceHandle);
322   }
323   delete (CPDF_ProgressiveImageLoaderHandle*)m_LoadHandle;
324   delete m_pClone;
325 }
326 FX_BOOL CPDF_ImageRenderer::StartLoadDIBSource() {
327   CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
328   FX_RECT image_rect = image_rect_f.GetOutterRect();
329   int dest_width = image_rect.Width();
330   int dest_height = image_rect.Height();
331   if (m_ImageMatrix.a < 0) {
332     dest_width = -dest_width;
333   }
334   if (m_ImageMatrix.d > 0) {
335     dest_height = -dest_height;
336   }
337   if (m_Loader.StartLoadImage(
338           m_pImageObject, m_pRenderStatus->m_pContext->m_pPageCache,
339           m_LoadHandle, m_bStdCS, m_pRenderStatus->m_GroupFamily,
340           m_pRenderStatus->m_bLoadMask, m_pRenderStatus, dest_width,
341           dest_height)) {
342     if (m_LoadHandle != NULL) {
343       m_Status = 4;
344       return TRUE;
345     }
346     return FALSE;
347   }
348   return FALSE;
349 }
350 FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource() {
351   if (m_Loader.m_pBitmap == NULL) {
352     return FALSE;
353   }
354   m_BitmapAlpha = 255;
355   const CPDF_GeneralStateData* pGeneralState = m_pImageObject->m_GeneralState;
356   if (pGeneralState) {
357     m_BitmapAlpha = FXSYS_round(pGeneralState->m_FillAlpha * 255);
358   }
359   m_pDIBSource = m_Loader.m_pBitmap;
360   if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_ALPHA &&
361       m_Loader.m_pMask == NULL) {
362     return StartBitmapAlpha();
363   }
364   if (pGeneralState && pGeneralState->m_pTR) {
365     if (!pGeneralState->m_pTransferFunc) {
366       ((CPDF_GeneralStateData*)pGeneralState)->m_pTransferFunc =
367           m_pRenderStatus->GetTransferFunc(pGeneralState->m_pTR);
368     }
369     if (pGeneralState->m_pTransferFunc &&
370         !pGeneralState->m_pTransferFunc->m_bIdentity) {
371       m_pDIBSource = m_Loader.m_pBitmap =
372           pGeneralState->m_pTransferFunc->TranslateImage(m_Loader.m_pBitmap,
373                                                          !m_Loader.m_bCached);
374       if (m_Loader.m_bCached && m_Loader.m_pMask) {
375         m_Loader.m_pMask = m_Loader.m_pMask->Clone();
376       }
377       m_Loader.m_bCached = FALSE;
378     }
379   }
380   m_FillArgb = 0;
381   m_bPatternColor = FALSE;
382   m_pPattern = NULL;
383   if (m_pDIBSource->IsAlphaMask()) {
384     CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor();
385     if (pColor && pColor->IsPattern()) {
386       m_pPattern = pColor->GetPattern();
387       if (m_pPattern != NULL) {
388         m_bPatternColor = TRUE;
389       }
390     }
391     m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject);
392   } else if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_GRAY) {
393     m_pClone = m_pDIBSource->Clone();
394     m_pClone->ConvertColorScale(m_pRenderStatus->m_Options.m_BackColor,
395                                 m_pRenderStatus->m_Options.m_ForeColor);
396     m_pDIBSource = m_pClone;
397   }
398   m_Flags = 0;
399   if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_DOWNSAMPLE) {
400     m_Flags |= RENDER_FORCE_DOWNSAMPLE;
401   } else if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_HALFTONE) {
402     m_Flags |= RENDER_FORCE_HALFTONE;
403   }
404   if (m_pRenderStatus->m_pDevice->GetDeviceClass() != FXDC_DISPLAY) {
405     CPDF_Object* pFilters =
406         m_pImageObject->m_pImage->GetStream()->GetDict()->GetElementValue(
407             FX_BSTRC("Filter"));
408     if (pFilters) {
409       if (pFilters->GetType() == PDFOBJ_NAME) {
410         CFX_ByteStringC bsDecodeType = pFilters->GetConstString();
411         if (bsDecodeType == FX_BSTRC("DCTDecode") ||
412             bsDecodeType == FX_BSTRC("JPXDecode")) {
413           m_Flags |= FXRENDER_IMAGE_LOSSY;
414         }
415       } else if (pFilters->GetType() == PDFOBJ_ARRAY) {
416         CPDF_Array* pArray = (CPDF_Array*)pFilters;
417         for (FX_DWORD i = 0; i < pArray->GetCount(); i++) {
418           CFX_ByteStringC bsDecodeType = pArray->GetConstString(i);
419           if (bsDecodeType == FX_BSTRC("DCTDecode") ||
420               bsDecodeType == FX_BSTRC("JPXDecode")) {
421             m_Flags |= FXRENDER_IMAGE_LOSSY;
422             break;
423           }
424         }
425       }
426     }
427   }
428   if (m_pRenderStatus->m_Options.m_Flags & RENDER_NOIMAGESMOOTH) {
429     m_Flags |= FXDIB_NOSMOOTH;
430   } else if (m_pImageObject->m_pImage->IsInterpol()) {
431     m_Flags |= FXDIB_INTERPOL;
432   }
433   if (m_Loader.m_pMask) {
434     return DrawMaskedImage();
435   }
436   if (m_bPatternColor) {
437     return DrawPatternImage(m_pObj2Device);
438   }
439   if (m_BitmapAlpha == 255 && pGeneralState && pGeneralState->m_FillOP &&
440       pGeneralState->m_OPMode == 0 &&
441       pGeneralState->m_BlendType == FXDIB_BLEND_NORMAL &&
442       pGeneralState->m_StrokeAlpha == 1 && pGeneralState->m_FillAlpha == 1) {
443     CPDF_Document* pDocument = NULL;
444     CPDF_Page* pPage = NULL;
445     if (m_pRenderStatus->m_pContext->m_pPageCache) {
446       pPage = m_pRenderStatus->m_pContext->m_pPageCache->GetPage();
447       pDocument = pPage->m_pDocument;
448     } else {
449       pDocument = m_pImageObject->m_pImage->GetDocument();
450     }
451     CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : NULL;
452     CPDF_Object* pCSObj =
453         m_pImageObject->m_pImage->GetStream()->GetDict()->GetElementValue(
454             FX_BSTRC("ColorSpace"));
455     CPDF_ColorSpace* pColorSpace =
456         pDocument->LoadColorSpace(pCSObj, pPageResources);
457     if (pColorSpace) {
458       int format = pColorSpace->GetFamily();
459       if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
460           format == PDFCS_DEVICEN) {
461         m_BlendType = FXDIB_BLEND_DARKEN;
462       }
463       pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
464     }
465   }
466   return StartDIBSource();
467 }
468 FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
469                                   const CPDF_PageObject* pObj,
470                                   const CFX_AffineMatrix* pObj2Device,
471                                   FX_BOOL bStdCS,
472                                   int blendType) {
473   m_pRenderStatus = pStatus;
474   m_bStdCS = bStdCS;
475   m_pImageObject = (CPDF_ImageObject*)pObj;
476   m_BlendType = blendType;
477   m_pObj2Device = pObj2Device;
478   CPDF_Dictionary* pOC = m_pImageObject->m_pImage->GetOC();
479   if (pOC && m_pRenderStatus->m_Options.m_pOCContext &&
480       !m_pRenderStatus->m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
481     return FALSE;
482   }
483   m_ImageMatrix = m_pImageObject->m_Matrix;
484   m_ImageMatrix.Concat(*pObj2Device);
485   if (StartLoadDIBSource()) {
486     return TRUE;
487   }
488   return StartRenderDIBSource();
489 }
490 FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
491                                   const CFX_DIBSource* pDIBSource,
492                                   FX_ARGB bitmap_argb,
493                                   int bitmap_alpha,
494                                   const CFX_AffineMatrix* pImage2Device,
495                                   FX_DWORD flags,
496                                   FX_BOOL bStdCS,
497                                   int blendType) {
498   m_pRenderStatus = pStatus;
499   m_pDIBSource = pDIBSource;
500   m_FillArgb = bitmap_argb;
501   m_BitmapAlpha = bitmap_alpha;
502   m_ImageMatrix = *pImage2Device;
503   m_Flags = flags;
504   m_bStdCS = bStdCS;
505   m_BlendType = blendType;
506   return StartDIBSource();
507 }
508 FX_BOOL CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) {
509   if (m_pRenderStatus->m_bPrint &&
510       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
511     m_Result = FALSE;
512     return FALSE;
513   }
514   FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
515   rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
516   if (rect.IsEmpty()) {
517     return FALSE;
518   }
519   CFX_AffineMatrix new_matrix = m_ImageMatrix;
520   new_matrix.TranslateI(-rect.left, -rect.top);
521   int width = rect.Width();
522   int height = rect.Height();
523   CFX_FxgeDevice bitmap_device1;
524   if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32)) {
525     return TRUE;
526   }
527   bitmap_device1.GetBitmap()->Clear(0xffffff);
528   {
529     CPDF_RenderStatus bitmap_render;
530     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, NULL,
531                              NULL, NULL, NULL, &m_pRenderStatus->m_Options, 0,
532                              m_pRenderStatus->m_bDropObjects, NULL, TRUE);
533     CFX_Matrix patternDevice = *pObj2Device;
534     patternDevice.Translate((FX_FLOAT)-rect.left, (FX_FLOAT)-rect.top);
535     if (m_pPattern->m_PatternType == PATTERN_TILING) {
536       bitmap_render.DrawTilingPattern((CPDF_TilingPattern*)m_pPattern,
537                                       m_pImageObject, &patternDevice, FALSE);
538     } else {
539       bitmap_render.DrawShadingPattern((CPDF_ShadingPattern*)m_pPattern,
540                                        m_pImageObject, &patternDevice, FALSE);
541     }
542   }
543   {
544     CFX_FxgeDevice bitmap_device2;
545     if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb)) {
546       return TRUE;
547     }
548     bitmap_device2.GetBitmap()->Clear(0);
549     CPDF_RenderStatus bitmap_render;
550     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, NULL,
551                              NULL, NULL, NULL, NULL, 0,
552                              m_pRenderStatus->m_bDropObjects, NULL, TRUE);
553     CPDF_ImageRenderer image_render;
554     if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255,
555                            &new_matrix, m_Flags, TRUE)) {
556       image_render.Continue(NULL);
557     }
558     if (m_Loader.m_MatteColor != 0xffffffff) {
559       int matte_r = FXARGB_R(m_Loader.m_MatteColor);
560       int matte_g = FXARGB_G(m_Loader.m_MatteColor);
561       int matte_b = FXARGB_B(m_Loader.m_MatteColor);
562       for (int row = 0; row < height; row++) {
563         uint8_t* dest_scan =
564             (uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row);
565         const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
566         for (int col = 0; col < width; col++) {
567           int alpha = *mask_scan++;
568           if (alpha) {
569             int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
570             if (orig < 0) {
571               orig = 0;
572             } else if (orig > 255) {
573               orig = 255;
574             }
575             *dest_scan++ = orig;
576             orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
577             if (orig < 0) {
578               orig = 0;
579             } else if (orig > 255) {
580               orig = 255;
581             }
582             *dest_scan++ = orig;
583             orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
584             if (orig < 0) {
585               orig = 0;
586             } else if (orig > 255) {
587               orig = 255;
588             }
589             *dest_scan++ = orig;
590             dest_scan++;
591           } else {
592             dest_scan += 4;
593           }
594         }
595       }
596     }
597     bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
598     bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
599     bitmap_device1.GetBitmap()->MultiplyAlpha(255);
600   }
601   m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left,
602                                         rect.top, m_BlendType);
603   return FALSE;
604 }
605 FX_BOOL CPDF_ImageRenderer::DrawMaskedImage() {
606   if (m_pRenderStatus->m_bPrint &&
607       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
608     m_Result = FALSE;
609     return FALSE;
610   }
611   FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOutterRect();
612   rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox());
613   if (rect.IsEmpty()) {
614     return FALSE;
615   }
616   CFX_AffineMatrix new_matrix = m_ImageMatrix;
617   new_matrix.TranslateI(-rect.left, -rect.top);
618   int width = rect.Width();
619   int height = rect.Height();
620   CFX_FxgeDevice bitmap_device1;
621   if (!bitmap_device1.Create(width, height, FXDIB_Rgb32)) {
622     return TRUE;
623   }
624   bitmap_device1.GetBitmap()->Clear(0xffffff);
625   {
626     CPDF_RenderStatus bitmap_render;
627     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, NULL,
628                              NULL, NULL, NULL, NULL, 0,
629                              m_pRenderStatus->m_bDropObjects, NULL, TRUE);
630     CPDF_ImageRenderer image_render;
631     if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix,
632                            m_Flags, TRUE)) {
633       image_render.Continue(NULL);
634     }
635   }
636   {
637     CFX_FxgeDevice bitmap_device2;
638     if (!bitmap_device2.Create(width, height, FXDIB_8bppRgb)) {
639       return TRUE;
640     }
641     bitmap_device2.GetBitmap()->Clear(0);
642     CPDF_RenderStatus bitmap_render;
643     bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, NULL,
644                              NULL, NULL, NULL, NULL, 0,
645                              m_pRenderStatus->m_bDropObjects, NULL, TRUE);
646     CPDF_ImageRenderer image_render;
647     if (image_render.Start(&bitmap_render, m_Loader.m_pMask, 0xffffffff, 255,
648                            &new_matrix, m_Flags, TRUE)) {
649       image_render.Continue(NULL);
650     }
651     if (m_Loader.m_MatteColor != 0xffffffff) {
652       int matte_r = FXARGB_R(m_Loader.m_MatteColor);
653       int matte_g = FXARGB_G(m_Loader.m_MatteColor);
654       int matte_b = FXARGB_B(m_Loader.m_MatteColor);
655       for (int row = 0; row < height; row++) {
656         uint8_t* dest_scan =
657             (uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row);
658         const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row);
659         for (int col = 0; col < width; col++) {
660           int alpha = *mask_scan++;
661           if (alpha) {
662             int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
663             if (orig < 0) {
664               orig = 0;
665             } else if (orig > 255) {
666               orig = 255;
667             }
668             *dest_scan++ = orig;
669             orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
670             if (orig < 0) {
671               orig = 0;
672             } else if (orig > 255) {
673               orig = 255;
674             }
675             *dest_scan++ = orig;
676             orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
677             if (orig < 0) {
678               orig = 0;
679             } else if (orig > 255) {
680               orig = 255;
681             }
682             *dest_scan++ = orig;
683             dest_scan++;
684           } else {
685             dest_scan += 4;
686           }
687         }
688       }
689     }
690     bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
691     bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
692     if (m_BitmapAlpha < 255) {
693       bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
694     }
695   }
696   m_pRenderStatus->m_pDevice->SetDIBits(bitmap_device1.GetBitmap(), rect.left,
697                                         rect.top, m_BlendType);
698   return FALSE;
699 }
700 FX_BOOL CPDF_ImageRenderer::StartDIBSource() {
701   if (!(m_Flags & RENDER_FORCE_DOWNSAMPLE) && m_pDIBSource->GetBPP() > 1) {
702     int image_size = m_pDIBSource->GetBPP() / 8 * m_pDIBSource->GetWidth() *
703                      m_pDIBSource->GetHeight();
704     if (image_size > FPDF_HUGE_IMAGE_SIZE &&
705         !(m_Flags & RENDER_FORCE_HALFTONE)) {
706       m_Flags |= RENDER_FORCE_DOWNSAMPLE;
707     }
708   }
709   if (m_pRenderStatus->m_pDevice->StartDIBits(
710           m_pDIBSource, m_BitmapAlpha, m_FillArgb, &m_ImageMatrix, m_Flags,
711           m_DeviceHandle, 0, NULL, m_BlendType)) {
712     if (m_DeviceHandle != NULL) {
713       m_Status = 3;
714       return TRUE;
715     }
716     return FALSE;
717   }
718   CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
719   FX_RECT image_rect = image_rect_f.GetOutterRect();
720   int dest_width = image_rect.Width();
721   int dest_height = image_rect.Height();
722   if ((FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
723       (FXSYS_fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0)) {
724     if (m_pRenderStatus->m_bPrint &&
725         !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
726       m_Result = FALSE;
727       return FALSE;
728     }
729     FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
730     clip_box.Intersect(image_rect);
731     m_Status = 2;
732     m_pTransformer = new CFX_ImageTransformer;
733     m_pTransformer->Start(m_pDIBSource, &m_ImageMatrix, m_Flags, &clip_box);
734     return TRUE;
735   }
736   if (m_ImageMatrix.a < 0) {
737     dest_width = -dest_width;
738   }
739   if (m_ImageMatrix.d > 0) {
740     dest_height = -dest_height;
741   }
742   int dest_left, dest_top;
743   dest_left = dest_width > 0 ? image_rect.left : image_rect.right;
744   dest_top = dest_height > 0 ? image_rect.top : image_rect.bottom;
745   if (m_pDIBSource->IsOpaqueImage() && m_BitmapAlpha == 255) {
746     if (m_pRenderStatus->m_pDevice->StretchDIBits(
747             m_pDIBSource, dest_left, dest_top, dest_width, dest_height, m_Flags,
748             NULL, m_BlendType)) {
749       return FALSE;
750     }
751   }
752   if (m_pDIBSource->IsAlphaMask()) {
753     if (m_BitmapAlpha != 255) {
754       m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
755     }
756     if (m_pRenderStatus->m_pDevice->StretchBitMask(
757             m_pDIBSource, dest_left, dest_top, dest_width, dest_height,
758             m_FillArgb, m_Flags)) {
759       return FALSE;
760     }
761   }
762   if (m_pRenderStatus->m_bPrint &&
763       !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
764     m_Result = FALSE;
765     return TRUE;
766   }
767   FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox();
768   FX_RECT dest_rect = clip_box;
769   dest_rect.Intersect(image_rect);
770   FX_RECT dest_clip(
771       dest_rect.left - image_rect.left, dest_rect.top - image_rect.top,
772       dest_rect.right - image_rect.left, dest_rect.bottom - image_rect.top);
773   CFX_DIBitmap* pStretched =
774       m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip);
775   if (pStretched) {
776     m_pRenderStatus->CompositeDIBitmap(pStretched, dest_rect.left,
777                                        dest_rect.top, m_FillArgb, m_BitmapAlpha,
778                                        m_BlendType, FALSE);
779     delete pStretched;
780     pStretched = NULL;
781   }
782   return FALSE;
783 }
784 FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha() {
785   if (m_pDIBSource->IsOpaqueImage()) {
786     CFX_PathData path;
787     path.AppendRect(0, 0, 1, 1);
788     path.Transform(&m_ImageMatrix);
789     FX_DWORD fill_color =
790         ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha);
791     m_pRenderStatus->m_pDevice->DrawPath(&path, NULL, NULL, fill_color, 0,
792                                          FXFILL_WINDING);
793   } else {
794     const CFX_DIBSource* pAlphaMask = m_pDIBSource->IsAlphaMask()
795                                           ? m_pDIBSource
796                                           : m_pDIBSource->GetAlphaMask();
797     if (FXSYS_fabs(m_ImageMatrix.b) >= 0.5f ||
798         FXSYS_fabs(m_ImageMatrix.c) >= 0.5f) {
799       int left, top;
800       CFX_DIBitmap* pTransformed =
801           pAlphaMask->TransformTo(&m_ImageMatrix, left, top);
802       if (pTransformed == NULL) {
803         return TRUE;
804       }
805       m_pRenderStatus->m_pDevice->SetBitMask(
806           pTransformed, left, top,
807           ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
808       delete pTransformed;
809     } else {
810       CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
811       FX_RECT image_rect = image_rect_f.GetOutterRect();
812       int dest_width =
813           m_ImageMatrix.a > 0 ? image_rect.Width() : -image_rect.Width();
814       int dest_height =
815           m_ImageMatrix.d > 0 ? -image_rect.Height() : image_rect.Height();
816       int left = dest_width > 0 ? image_rect.left : image_rect.right;
817       int top = dest_height > 0 ? image_rect.top : image_rect.bottom;
818       m_pRenderStatus->m_pDevice->StretchBitMask(
819           pAlphaMask, left, top, dest_width, dest_height,
820           ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
821     }
822     if (m_pDIBSource != pAlphaMask) {
823       delete pAlphaMask;
824     }
825   }
826   return FALSE;
827 }
828 FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause) {
829   if (m_Status == 1) {
830     if (m_pQuickStretcher->Continue(pPause)) {
831       return TRUE;
832     }
833     if (m_pQuickStretcher->m_pBitmap->IsAlphaMask())
834       m_pRenderStatus->m_pDevice->SetBitMask(
835           m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
836           m_pQuickStretcher->m_ResultTop, m_FillArgb);
837     else
838       m_pRenderStatus->m_pDevice->SetDIBits(
839           m_pQuickStretcher->m_pBitmap, m_pQuickStretcher->m_ResultLeft,
840           m_pQuickStretcher->m_ResultTop, m_BlendType);
841     return FALSE;
842   }
843   if (m_Status == 2) {
844     if (m_pTransformer->Continue(pPause)) {
845       return TRUE;
846     }
847     CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
848     if (pBitmap == NULL) {
849       return FALSE;
850     }
851     if (pBitmap->IsAlphaMask()) {
852       if (m_BitmapAlpha != 255) {
853         m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
854       }
855       m_Result = m_pRenderStatus->m_pDevice->SetBitMask(
856           pBitmap, m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
857           m_FillArgb);
858     } else {
859       if (m_BitmapAlpha != 255) {
860         pBitmap->MultiplyAlpha(m_BitmapAlpha);
861       }
862       m_Result = m_pRenderStatus->m_pDevice->SetDIBits(
863           pBitmap, m_pTransformer->m_ResultLeft, m_pTransformer->m_ResultTop,
864           m_BlendType);
865     }
866     delete pBitmap;
867     return FALSE;
868   }
869   if (m_Status == 3) {
870     return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
871   }
872   if (m_Status == 4) {
873     if (m_Loader.Continue(m_LoadHandle, pPause)) {
874       return TRUE;
875     }
876     if (StartRenderDIBSource()) {
877       return Continue(pPause);
878     }
879   }
880   return FALSE;
881 }
882 CPDF_QuickStretcher::CPDF_QuickStretcher() {
883   m_pBitmap = NULL;
884   m_pDecoder = NULL;
885   m_pCS = NULL;
886 }
887 CPDF_QuickStretcher::~CPDF_QuickStretcher() {
888   delete m_pBitmap;
889   if (m_pCS) {
890     m_pCS->ReleaseCS();
891   }
892   delete m_pDecoder;
893 }
894 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
895     const uint8_t* src_buf,
896     FX_DWORD src_size,
897     int width,
898     int height,
899     int nComps,
900     int bpc,
901     const CPDF_Dictionary* pParams);
902 FX_BOOL CPDF_QuickStretcher::Start(CPDF_ImageObject* pImageObj,
903                                    CFX_AffineMatrix* pImage2Device,
904                                    const FX_RECT* pClipBox) {
905   if (FXSYS_fabs(pImage2Device->a) < FXSYS_fabs(pImage2Device->b) * 10 &&
906       FXSYS_fabs(pImage2Device->d) < FXSYS_fabs(pImage2Device->c) * 10) {
907     return FALSE;
908   }
909   CFX_FloatRect image_rect_f = pImage2Device->GetUnitRect();
910   FX_RECT image_rect = image_rect_f.GetOutterRect();
911   m_DestWidth = image_rect.Width();
912   m_DestHeight = image_rect.Height();
913   m_bFlipX = pImage2Device->a < 0;
914   m_bFlipY = pImage2Device->d > 0;
915   FX_RECT result_rect = *pClipBox;
916   result_rect.Intersect(image_rect);
917   if (result_rect.IsEmpty()) {
918     return FALSE;
919   }
920   m_ResultWidth = result_rect.Width();
921   m_ResultHeight = result_rect.Height();
922   m_ResultLeft = result_rect.left;
923   m_ResultTop = result_rect.top;
924   m_ClipLeft = result_rect.left - image_rect.left;
925   m_ClipTop = result_rect.top - image_rect.top;
926   CPDF_Dictionary* pDict = pImageObj->m_pImage->GetDict();
927   if (pDict->GetInteger(FX_BSTRC("BitsPerComponent")) != 8) {
928     return FALSE;
929   }
930   if (pDict->KeyExist(FX_BSTRC("SMask")) || pDict->KeyExist(FX_BSTRC("Mask"))) {
931     return FALSE;
932   }
933   m_SrcWidth = pDict->GetInteger(FX_BSTRC("Width"));
934   m_SrcHeight = pDict->GetInteger(FX_BSTRC("Height"));
935   m_pCS = NULL;
936   m_Bpp = 3;
937   CPDF_Object* pCSObj = pDict->GetElementValue(FX_BSTRC("ColorSpace"));
938   if (pCSObj == NULL) {
939     return FALSE;
940   }
941   m_pCS = CPDF_ColorSpace::Load(pImageObj->m_pImage->GetDocument(), pCSObj);
942   if (m_pCS == NULL) {
943     return FALSE;
944   }
945   if (!_IsSupported(m_pCS)) {
946     return FALSE;
947   }
948   m_Bpp = m_pCS->CountComponents();
949   if (m_pCS->sRGB()) {
950     m_pCS->ReleaseCS();
951     m_pCS = NULL;
952   }
953   CPDF_Stream* pStream = pImageObj->m_pImage->GetStream();
954   m_StreamAcc.LoadAllData(pStream, FALSE, m_SrcWidth * m_SrcHeight * m_Bpp,
955                           TRUE);
956   m_pDecoder = NULL;
957   if (!m_StreamAcc.GetImageDecoder().IsEmpty()) {
958     if (m_StreamAcc.GetImageDecoder() == FX_BSTRC("DCTDecode")) {
959       const CPDF_Dictionary* pParam = m_StreamAcc.GetImageParam();
960       m_pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
961           m_StreamAcc.GetData(), m_StreamAcc.GetSize(), m_SrcWidth, m_SrcHeight,
962           m_Bpp,
963           pParam ? pParam->GetInteger(FX_BSTRC("ColorTransform"), 1) : 1);
964     } else if (m_StreamAcc.GetImageDecoder() == FX_BSTRC("FlateDecode")) {
965       m_pDecoder = FPDFAPI_CreateFlateDecoder(
966           m_StreamAcc.GetData(), m_StreamAcc.GetSize(), m_SrcWidth, m_SrcHeight,
967           m_Bpp, 8, m_StreamAcc.GetImageParam());
968     } else {
969       return FALSE;
970     }
971     m_pDecoder->DownScale(m_DestWidth, m_DestHeight);
972   }
973   m_pBitmap = new CFX_DIBitmap;
974 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
975   m_pBitmap->Create(m_ResultWidth, m_ResultHeight, FXDIB_Rgb32);
976 #else
977   m_pBitmap->Create(m_ResultWidth, m_ResultHeight, FXDIB_Rgb);
978 #endif
979   m_LineIndex = 0;
980   return TRUE;
981 }
982 FX_BOOL CPDF_QuickStretcher::Continue(IFX_Pause* pPause) {
983   uint8_t* result_buf = m_pBitmap->GetBuffer();
984   int src_width = m_pDecoder ? m_pDecoder->GetWidth() : m_SrcWidth;
985   int src_height = m_pDecoder ? m_pDecoder->GetHeight() : m_SrcHeight;
986   int src_pitch = src_width * m_Bpp;
987   while (m_LineIndex < m_ResultHeight) {
988     int dest_y, src_y;
989     if (m_bFlipY) {
990       dest_y = m_ResultHeight - m_LineIndex - 1;
991       src_y =
992           (m_DestHeight - (dest_y + m_ClipTop) - 1) * src_height / m_DestHeight;
993     } else {
994       dest_y = m_LineIndex;
995       src_y = (dest_y + m_ClipTop) * src_height / m_DestHeight;
996     }
997     const uint8_t* src_scan;
998     if (m_pDecoder) {
999       src_scan = m_pDecoder->GetScanline(src_y);
1000       if (src_scan == NULL) {
1001         break;
1002       }
1003     } else {
1004       src_scan = m_StreamAcc.GetData();
1005       if (src_scan == NULL) {
1006         break;
1007       }
1008       src_scan += src_y * src_pitch;
1009     }
1010     uint8_t* result_scan = result_buf + dest_y * m_pBitmap->GetPitch();
1011     for (int x = 0; x < m_ResultWidth; x++) {
1012       int dest_x = m_ClipLeft + x;
1013       int src_x = (m_bFlipX ? (m_DestWidth - dest_x - 1) : dest_x) * src_width /
1014                   m_DestWidth;
1015       const uint8_t* src_pixel = src_scan + src_x * m_Bpp;
1016       if (m_pCS == NULL) {
1017         *result_scan = src_pixel[2];
1018         result_scan++;
1019         *result_scan = src_pixel[1];
1020         result_scan++;
1021         *result_scan = src_pixel[0];
1022         result_scan++;
1023 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
1024         result_scan++;
1025 #endif
1026       } else {
1027         m_pCS->TranslateImageLine(result_scan, src_pixel, 1, 0, 0);
1028 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
1029         result_scan += 4;
1030 #else
1031         result_scan += 3;
1032 #endif
1033       }
1034     }
1035     m_LineIndex++;
1036     if (pPause && pPause->NeedToPauseNow()) {
1037       return TRUE;
1038     }
1039   }
1040   return FALSE;
1041 }
1042 CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict,
1043                                            FX_RECT* pClipRect,
1044                                            const CFX_AffineMatrix* pMatrix) {
1045   if (pSMaskDict == NULL) {
1046     return NULL;
1047   }
1048   CFX_DIBitmap* pMask = NULL;
1049   int width = pClipRect->right - pClipRect->left;
1050   int height = pClipRect->bottom - pClipRect->top;
1051   FX_BOOL bLuminosity = FALSE;
1052   bLuminosity = pSMaskDict->GetConstString(FX_BSTRC("S")) != FX_BSTRC("Alpha");
1053   CPDF_Stream* pGroup = pSMaskDict->GetStream(FX_BSTRC("G"));
1054   if (pGroup == NULL) {
1055     return NULL;
1056   }
1057   CPDF_Function* pFunc = NULL;
1058   CPDF_Object* pFuncObj = pSMaskDict->GetElementValue(FX_BSTRC("TR"));
1059   if (pFuncObj && (pFuncObj->GetType() == PDFOBJ_DICTIONARY ||
1060                    pFuncObj->GetType() == PDFOBJ_STREAM)) {
1061     pFunc = CPDF_Function::Load(pFuncObj);
1062   }
1063   CFX_AffineMatrix matrix = *pMatrix;
1064   matrix.TranslateI(-pClipRect->left, -pClipRect->top);
1065   CPDF_Form form(m_pContext->m_pDocument, m_pContext->m_pPageResources, pGroup);
1066   form.ParseContent(NULL, NULL, NULL, NULL);
1067   CFX_FxgeDevice bitmap_device;
1068 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
1069   if (!bitmap_device.Create(width, height,
1070                             bLuminosity ? FXDIB_Rgb32 : FXDIB_8bppMask)) {
1071     return NULL;
1072   }
1073 #else
1074   if (!bitmap_device.Create(width, height,
1075                             bLuminosity ? FXDIB_Rgb : FXDIB_8bppMask)) {
1076     return NULL;
1077   }
1078 #endif
1079   CFX_DIBitmap& bitmap = *bitmap_device.GetBitmap();
1080   CPDF_Object* pCSObj = NULL;
1081   CPDF_ColorSpace* pCS = NULL;
1082   if (bLuminosity) {
1083     CPDF_Array* pBC = pSMaskDict->GetArray(FX_BSTRC("BC"));
1084     FX_ARGB back_color = 0xff000000;
1085     if (pBC) {
1086       CPDF_Dictionary* pDict = pGroup->GetDict();
1087       if (pDict && pDict->GetDict(FX_BSTRC("Group")))
1088         pCSObj =
1089             pDict->GetDict(FX_BSTRC("Group"))->GetElementValue(FX_BSTRC("CS"));
1090       else
1091         pCSObj = NULL;
1092       pCS = m_pContext->m_pDocument->LoadColorSpace(pCSObj);
1093       if (pCS) {
1094         FX_FLOAT R, G, B;
1095         FX_DWORD comps = 8;
1096         if (pCS->CountComponents() > static_cast<int32_t>(comps)) {
1097           comps = (FX_DWORD)pCS->CountComponents();
1098         }
1099         CFX_FixedBufGrow<FX_FLOAT, 8> float_array(comps);
1100         FX_FLOAT* pFloats = float_array;
1101         FX_SAFE_DWORD num_floats = comps;
1102         num_floats *= sizeof(FX_FLOAT);
1103         if (!num_floats.IsValid()) {
1104           return NULL;
1105         }
1106         FXSYS_memset(pFloats, 0, num_floats.ValueOrDie());
1107         int count = pBC->GetCount() > 8 ? 8 : pBC->GetCount();
1108         for (int i = 0; i < count; i++) {
1109           pFloats[i] = pBC->GetNumber(i);
1110         }
1111         pCS->GetRGB(pFloats, R, G, B);
1112         back_color = 0xff000000 | ((int32_t)(R * 255) << 16) |
1113                      ((int32_t)(G * 255) << 8) | (int32_t)(B * 255);
1114         m_pContext->m_pDocument->GetPageData()->ReleaseColorSpace(pCSObj);
1115       }
1116     }
1117     bitmap.Clear(back_color);
1118   } else {
1119     bitmap.Clear(0);
1120   }
1121   CPDF_Dictionary* pFormResource = NULL;
1122   if (form.m_pFormDict) {
1123     pFormResource = form.m_pFormDict->GetDict(FX_BSTRC("Resources"));
1124   }
1125   CPDF_RenderOptions options;
1126   options.m_ColorMode = bLuminosity ? RENDER_COLOR_NORMAL : RENDER_COLOR_ALPHA;
1127   CPDF_RenderStatus status;
1128   status.Initialize(m_pContext, &bitmap_device, NULL, NULL, NULL, NULL,
1129                     &options, 0, m_bDropObjects, pFormResource, TRUE, NULL, 0,
1130                     pCS ? pCS->GetFamily() : 0, bLuminosity);
1131   status.RenderObjectList(&form, &matrix);
1132   pMask = new CFX_DIBitmap;
1133   if (!pMask->Create(width, height, FXDIB_8bppMask)) {
1134     delete pMask;
1135     return NULL;
1136   }
1137   uint8_t* dest_buf = pMask->GetBuffer();
1138   int dest_pitch = pMask->GetPitch();
1139   uint8_t* src_buf = bitmap.GetBuffer();
1140   int src_pitch = bitmap.GetPitch();
1141   uint8_t* pTransfer = FX_Alloc(uint8_t, 256);
1142   if (pFunc) {
1143     CFX_FixedBufGrow<FX_FLOAT, 16> results(pFunc->CountOutputs());
1144     for (int i = 0; i < 256; i++) {
1145       FX_FLOAT input = (FX_FLOAT)i / 255.0f;
1146       int nresult;
1147       pFunc->Call(&input, 1, results, nresult);
1148       pTransfer[i] = FXSYS_round(results[0] * 255);
1149     }
1150   } else {
1151     for (int i = 0; i < 256; i++) {
1152       pTransfer[i] = i;
1153     }
1154   }
1155   if (bLuminosity) {
1156     int Bpp = bitmap.GetBPP() / 8;
1157     for (int row = 0; row < height; row++) {
1158       uint8_t* dest_pos = dest_buf + row * dest_pitch;
1159       uint8_t* src_pos = src_buf + row * src_pitch;
1160       for (int col = 0; col < width; col++) {
1161         *dest_pos++ = pTransfer[FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos)];
1162         src_pos += Bpp;
1163       }
1164     }
1165   } else if (pFunc) {
1166     int size = dest_pitch * height;
1167     for (int i = 0; i < size; i++) {
1168       dest_buf[i] = pTransfer[src_buf[i]];
1169     }
1170   } else {
1171     FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height);
1172   }
1173   delete pFunc;
1174   FX_Free(pTransfer);
1175   return pMask;
1176 }