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