f938628f55f9df743e030cbda2e2e05f5e1fe87c
[pdfium.git] / core / src / fpdfapi / fpdf_render / fpdf_render_loadimage.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 "../../../src/fxcrt/fx_safe_types.h"
13 #include "../fpdf_page/pageint.h"
14 #include "render_int.h"
15
16 static unsigned int _GetBits8(FX_LPCBYTE pData, int bitpos, int nbits)
17 {
18     unsigned int byte = pData[bitpos / 8];
19     if (nbits == 8) {
20         return byte;
21     } else if (nbits == 4) {
22         return (bitpos % 8) ? (byte & 0x0f) : (byte >> 4);
23     } else if (nbits == 2) {
24         return (byte >> (6 - bitpos % 8)) & 0x03;
25     } else if (nbits == 1) {
26         return (byte >> (7 - bitpos % 8)) & 0x01;
27     } else if (nbits == 16) {
28         return byte * 256 + pData[bitpos / 8 + 1];
29     }
30     return 0;
31 }
32 CFX_DIBSource* CPDF_Image::LoadDIBSource(CFX_DIBSource** ppMask, FX_DWORD* pMatteColor, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask) const
33 {
34     CPDF_DIBSource* pSource = FX_NEW CPDF_DIBSource;
35     if (pSource->Load(m_pDocument, m_pStream, (CPDF_DIBSource**)ppMask, pMatteColor, NULL, NULL, bStdCS, GroupFamily, bLoadMask)) {
36         return pSource;
37     }
38     delete pSource;
39     return NULL;
40 }
41 CFX_DIBSource* CPDF_Image::DetachBitmap()
42 {
43     CFX_DIBSource* pBitmap = m_pDIBSource;
44     m_pDIBSource = NULL;
45     return pBitmap;
46 }
47 CFX_DIBSource* CPDF_Image::DetachMask()
48 {
49     CFX_DIBSource* pBitmap = m_pMask;
50     m_pMask = NULL;
51     return pBitmap;
52 }
53 FX_BOOL CPDF_Image::StartLoadDIBSource(CPDF_Dictionary* pFormResource, CPDF_Dictionary* pPageResource, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask)
54 {
55     m_pDIBSource = FX_NEW CPDF_DIBSource;
56     int ret = ((CPDF_DIBSource*)m_pDIBSource)->StartLoadDIBSource(m_pDocument, m_pStream, TRUE, pFormResource, pPageResource, bStdCS, GroupFamily, bLoadMask);
57     if (ret == 2) {
58         return TRUE;
59     }
60     if (!ret) {
61         delete m_pDIBSource;
62         m_pDIBSource = NULL;
63         return FALSE;
64     }
65     m_pMask = ((CPDF_DIBSource*)m_pDIBSource)->DetachMask();
66     m_MatteColor = ((CPDF_DIBSource*)m_pDIBSource)->m_MatteColor;
67     return FALSE;
68 }
69 FX_BOOL CPDF_Image::Continue(IFX_Pause* pPause)
70 {
71     int ret = ((CPDF_DIBSource*)m_pDIBSource)->ContinueLoadDIBSource(pPause);
72     if (ret == 2) {
73         return TRUE;
74     }
75     if (!ret) {
76         delete m_pDIBSource;
77         m_pDIBSource = NULL;
78         return FALSE;
79     }
80     m_pMask = ((CPDF_DIBSource*)m_pDIBSource)->DetachMask();
81     m_MatteColor = ((CPDF_DIBSource*)m_pDIBSource)->m_MatteColor;
82     return FALSE;
83 }
84 CPDF_DIBSource::CPDF_DIBSource()
85 {
86     m_pDocument = NULL;
87     m_pStreamAcc = NULL;
88     m_pDict = NULL;
89     m_bpp = 0;
90     m_Width = m_Height = 0;
91     m_pColorSpace = NULL;
92     m_bDefaultDecode = TRUE;
93     m_bImageMask = FALSE;
94     m_pPalette = NULL;
95     m_pCompData = NULL;
96     m_bColorKey = FALSE;
97     m_pMaskedLine = m_pLineBuf = NULL;
98     m_pCachedBitmap = NULL;
99     m_pDecoder = NULL;
100     m_nComponents = 0;
101     m_bpc = 0;
102     m_bLoadMask = FALSE;
103     m_Family = 0;
104     m_pMask = NULL;
105     m_MatteColor = 0;
106     m_pJbig2Context = NULL;
107     m_pGlobalStream = NULL;
108     m_bStdCS = FALSE;
109     m_pMaskStream = NULL;
110     m_Status = 0;
111     m_bHasMask = FALSE;
112 }
113 CPDF_DIBSource::~CPDF_DIBSource()
114 {
115     if (m_pStreamAcc) {
116         delete m_pStreamAcc;
117     }
118     if (m_pMaskedLine) {
119         FX_Free(m_pMaskedLine);
120     }
121     if (m_pLineBuf) {
122         FX_Free(m_pLineBuf);
123     }
124     if (m_pCachedBitmap) {
125         delete m_pCachedBitmap;
126     }
127     if (m_pDecoder) {
128         delete m_pDecoder;
129     }
130     if (m_pCompData) {
131         FX_Free(m_pCompData);
132     }
133     CPDF_ColorSpace* pCS = m_pColorSpace;
134     if (pCS && m_pDocument) {
135         m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
136     }
137     if (m_pJbig2Context) {
138         ICodec_Jbig2Module* pJbig2Moudle = CPDF_ModuleMgr::Get()->GetJbig2Module();
139         pJbig2Moudle->DestroyJbig2Context(m_pJbig2Context);
140         m_pJbig2Context = NULL;
141     }
142     if (m_pGlobalStream) {
143         delete m_pGlobalStream;
144     }
145     m_pGlobalStream = NULL;
146 }
147 CFX_DIBitmap* CPDF_DIBSource::GetBitmap() const
148 {
149     if (m_pCachedBitmap) {
150         return m_pCachedBitmap;
151     }
152     return Clone();
153 }
154 void CPDF_DIBSource::ReleaseBitmap(CFX_DIBitmap* pBitmap) const
155 {
156     if (pBitmap && pBitmap != m_pCachedBitmap) {
157         delete pBitmap;
158     }
159 }
160 FX_BOOL CPDF_DIBSource::Load(CPDF_Document* pDoc, const CPDF_Stream* pStream, CPDF_DIBSource** ppMask,
161                              FX_DWORD* pMatteColor, CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask)
162 {
163     if (pStream == NULL) {
164         return FALSE;
165     }
166     m_pDocument = pDoc;
167     m_pDict = pStream->GetDict();
168     if (m_pDict == NULL) {
169         return FALSE;
170     }
171     m_pStream = pStream;
172     m_Width = m_pDict->GetInteger(FX_BSTRC("Width"));
173     m_Height = m_pDict->GetInteger(FX_BSTRC("Height"));
174     if (m_Width <= 0 || m_Height <= 0 || m_Width > 0x01ffff || m_Height > 0x01ffff) {
175         return FALSE;
176     }
177     m_GroupFamily = GroupFamily;
178     m_bLoadMask = bLoadMask;
179     if (!LoadColorInfo(m_pStream->GetObjNum() != 0 ? NULL : pFormResources, pPageResources)) {
180         return FALSE;
181     }
182     if (m_bpc == 0 || m_nComponents == 0) {
183         return FALSE;
184     }
185     FX_SAFE_DWORD src_pitch = m_bpc;
186     src_pitch *= m_nComponents;
187     src_pitch *= m_Width;
188     src_pitch += 7;
189     src_pitch /= 8;
190     src_pitch *= m_Height;
191     if (!src_pitch.IsValid()) {
192         return FALSE;
193     }
194     m_pStreamAcc = FX_NEW CPDF_StreamAcc;
195     m_pStreamAcc->LoadAllData(pStream, FALSE, src_pitch.ValueOrDie(), TRUE);
196     if (m_pStreamAcc->GetSize() == 0 || m_pStreamAcc->GetData() == NULL) {
197         return FALSE;
198     }
199     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
200     if (!decoder.IsEmpty() && decoder == FX_BSTRC("CCITTFaxDecode")) {
201         m_bpc = 1;
202     }
203     if (!CreateDecoder()) {
204         return FALSE;
205     }
206     if (m_bImageMask) {
207         m_bpp = 1;
208         m_bpc = 1;
209         m_nComponents = 1;
210         m_AlphaFlag = 1;
211     } else if (m_bpc * m_nComponents == 1) {
212         m_bpp = 1;
213     } else if (m_bpc * m_nComponents <= 8) {
214         m_bpp = 8;
215     } else {
216         m_bpp = 24;
217     }
218     FX_SAFE_DWORD pitch = m_Width;
219     pitch *= m_bpp;
220     pitch += 31;
221     pitch /= 8;
222     if (!pitch.IsValid()) {
223         return FALSE;
224     }
225     m_pLineBuf = FX_Alloc(FX_BYTE, pitch.ValueOrDie());
226     if (m_pColorSpace && bStdCS) {
227         m_pColorSpace->EnableStdConversion(TRUE);
228     }
229     LoadPalette();
230     if (m_bColorKey) {
231         m_bpp = 32;
232         m_AlphaFlag = 2;
233         pitch = m_Width;
234         pitch *= m_bpp;
235         pitch += 31;
236         pitch /= 8;
237         if (!pitch.IsValid()) {
238             return FALSE;
239         }
240         m_pMaskedLine = FX_Alloc(FX_BYTE, pitch.ValueOrDie());
241     }
242     m_Pitch = pitch.ValueOrDie();
243     if (ppMask) {
244         *ppMask = LoadMask(*pMatteColor);
245     }
246     if (m_pColorSpace && bStdCS) {
247         m_pColorSpace->EnableStdConversion(FALSE);
248     }
249     return TRUE;
250 }
251 int     CPDF_DIBSource::ContinueToLoadMask()
252 {
253     if (m_bImageMask) {
254         m_bpp = 1;
255         m_bpc = 1;
256         m_nComponents = 1;
257         m_AlphaFlag = 1;
258     } else if (m_bpc * m_nComponents == 1) {
259         m_bpp = 1;
260     } else if (m_bpc * m_nComponents <= 8) {
261         m_bpp = 8;
262     } else {
263         m_bpp = 24;
264     }
265     if (!m_bpc || !m_nComponents) {
266         return 0;
267     }
268     FX_SAFE_DWORD pitch = m_Width;
269     pitch *= m_bpp;
270     pitch += 31;
271     pitch /= 8;
272     if (!pitch.IsValid()) {
273         return 0;
274     }
275     m_pLineBuf = FX_Alloc(FX_BYTE, pitch.ValueOrDie());
276     if (m_pColorSpace && m_bStdCS) {
277         m_pColorSpace->EnableStdConversion(TRUE);
278     }
279     LoadPalette();
280     if (m_bColorKey) {
281         m_bpp = 32;
282         m_AlphaFlag = 2;
283         pitch = m_Width;
284         pitch *= m_bpp;
285         pitch += 31;
286         pitch /= 8;
287         if (!pitch.IsValid()) {
288             return 0;
289         }
290         m_pMaskedLine = FX_Alloc(FX_BYTE, pitch.ValueOrDie());
291     }
292     m_Pitch = pitch.ValueOrDie();
293     return 1;
294 }
295 int     CPDF_DIBSource::StartLoadDIBSource(CPDF_Document* pDoc, const CPDF_Stream* pStream, FX_BOOL bHasMask,
296                                        CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources,
297                                        FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask)
298 {
299     if (pStream == NULL) {
300         return 0;
301     }
302     m_pDocument = pDoc;
303     m_pDict = pStream->GetDict();
304     m_pStream = pStream;
305     m_bStdCS = bStdCS;
306     m_bHasMask = bHasMask;
307     m_Width = m_pDict->GetInteger(FX_BSTRC("Width"));
308     m_Height = m_pDict->GetInteger(FX_BSTRC("Height"));
309     if (m_Width <= 0 || m_Height <= 0 || m_Width > 0x01ffff || m_Height > 0x01ffff) {
310         return 0;
311     }
312     m_GroupFamily = GroupFamily;
313     m_bLoadMask = bLoadMask;
314     if (!LoadColorInfo(m_pStream->GetObjNum() != 0 ? NULL : pFormResources, pPageResources)) {
315         return 0;
316     }
317     if (m_bpc == 0 || m_nComponents == 0) {
318         return 0;
319     }
320     FX_SAFE_DWORD src_pitch = m_bpc;
321     src_pitch *= m_nComponents;
322     src_pitch *= m_Width;
323     src_pitch += 7;
324     src_pitch /= 8;
325     src_pitch *= m_Height;
326     if (!src_pitch.IsValid()) {
327         return 0;
328     }
329     m_pStreamAcc = FX_NEW CPDF_StreamAcc;
330     m_pStreamAcc->LoadAllData(pStream, FALSE, src_pitch.ValueOrDie(), TRUE);
331     if (m_pStreamAcc->GetSize() == 0 || m_pStreamAcc->GetData() == NULL) {
332         return 0;
333     }
334     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
335     int ret = CreateDecoder();
336     if (ret != 1) {
337         if (!ret) {
338             return ret;
339         }
340         if (!ContinueToLoadMask()) {
341             return 0;
342         }
343         if (m_bHasMask) {
344             StratLoadMask();
345         }
346         return ret;
347     }
348     if (!ContinueToLoadMask()) {
349         return 0;
350     }
351     if (m_bHasMask) {
352         ret = StratLoadMask();
353     }
354     if (ret == 2) {
355         return ret;
356     }
357     if (m_pColorSpace && m_bStdCS) {
358         m_pColorSpace->EnableStdConversion(FALSE);
359     }
360     return ret;
361 }
362 int     CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause)
363 {
364     FXCODEC_STATUS ret;
365     if (m_Status == 1) {
366         const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
367         if (decoder == FX_BSTRC("JPXDecode")) {
368             return 0;
369         }
370         ICodec_Jbig2Module* pJbig2Moudle = CPDF_ModuleMgr::Get()->GetJbig2Module();
371         if (m_pJbig2Context == NULL) {
372             m_pJbig2Context = pJbig2Moudle->CreateJbig2Context();
373             if (m_pStreamAcc->GetImageParam()) {
374                 CPDF_Stream* pGlobals = m_pStreamAcc->GetImageParam()->GetStream(FX_BSTRC("JBIG2Globals"));
375                 if (pGlobals) {
376                     m_pGlobalStream = FX_NEW CPDF_StreamAcc;
377                     m_pGlobalStream->LoadAllData(pGlobals, FALSE);
378                 }
379             }
380             ret = pJbig2Moudle->StartDecode(m_pJbig2Context, m_Width, m_Height, m_pStreamAcc->GetData(), m_pStreamAcc->GetSize(),
381                                             m_pGlobalStream ? m_pGlobalStream->GetData() : NULL, m_pGlobalStream ? m_pGlobalStream->GetSize() : 0, m_pCachedBitmap->GetBuffer(),
382                                             m_pCachedBitmap->GetPitch(), pPause);
383             if (ret < 0) {
384                 delete m_pCachedBitmap;
385                 m_pCachedBitmap = NULL;
386                 if (m_pGlobalStream) {
387                     delete m_pGlobalStream;
388                 }
389                 m_pGlobalStream = NULL;
390                 pJbig2Moudle->DestroyJbig2Context(m_pJbig2Context);
391                 m_pJbig2Context = NULL;
392                 return 0;
393             }
394             if (ret == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
395                 return 2;
396             }
397             int ret1 = 1;
398             if (m_bHasMask) {
399                 ret1 = ContinueLoadMaskDIB(pPause);
400                 m_Status = 2;
401             }
402             if (ret1 == 2) {
403                 return ret1;
404             }
405             if (m_pColorSpace && m_bStdCS) {
406                 m_pColorSpace->EnableStdConversion(FALSE);
407             }
408             return ret1;
409         }
410         FXCODEC_STATUS ret = pJbig2Moudle->ContinueDecode(m_pJbig2Context, pPause);
411         if (ret < 0) {
412             delete m_pCachedBitmap;
413             m_pCachedBitmap = NULL;
414             if (m_pGlobalStream) {
415                 delete m_pGlobalStream;
416             }
417             m_pGlobalStream = NULL;
418             pJbig2Moudle->DestroyJbig2Context(m_pJbig2Context);
419             m_pJbig2Context = NULL;
420             return 0;
421         }
422         if (ret == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
423             return 2;
424         }
425         int ret1 = 1;
426         if (m_bHasMask) {
427             ret1 = ContinueLoadMaskDIB(pPause);
428             m_Status = 2;
429         }
430         if (ret1 == 2) {
431             return ret1;
432         }
433         if (m_pColorSpace && m_bStdCS) {
434             m_pColorSpace->EnableStdConversion(FALSE);
435         }
436         return ret1;
437     } else if (m_Status == 2) {
438         return ContinueLoadMaskDIB(pPause);
439     }
440     return 0;
441 }
442 FX_BOOL CPDF_DIBSource::LoadColorInfo(CPDF_Dictionary* pFormResources, CPDF_Dictionary* pPageResources)
443 {
444     m_bpc_orig = m_pDict->GetInteger(FX_BSTRC("BitsPerComponent"));
445     if (m_pDict->GetInteger("ImageMask")) {
446         m_bImageMask = TRUE;
447     }
448     if (m_bImageMask || !m_pDict->KeyExist(FX_BSTRC("ColorSpace"))) {
449         if (!m_bImageMask) {
450             CPDF_Object* pFilter = m_pDict->GetElementValue(FX_BSTRC("Filter"));
451             if (pFilter) {
452                 CFX_ByteString filter;
453                 if (pFilter->GetType() == PDFOBJ_NAME) {
454                     filter = pFilter->GetString();
455                     if (filter == FX_BSTRC("JPXDecode")) {
456                         return TRUE;
457                     }
458                 } else if (pFilter->GetType() == PDFOBJ_ARRAY) {
459                     CPDF_Array* pArray = (CPDF_Array*)pFilter;
460                     if (pArray->GetString(pArray->GetCount() - 1) == FX_BSTRC("JPXDecode")) {
461                         return TRUE;
462                     }
463                 }
464             }
465         }
466         m_bImageMask = TRUE;
467         m_bpc = m_nComponents = 1;
468         CPDF_Array* pDecode = m_pDict->GetArray(FX_BSTRC("Decode"));
469         m_bDefaultDecode = pDecode == NULL || pDecode->GetInteger(0) == 0;
470         return TRUE;
471     }
472     CPDF_Object* pCSObj = m_pDict->GetElementValue(FX_BSTRC("ColorSpace"));
473     if (pCSObj == NULL) {
474         return FALSE;
475     }
476     CPDF_DocPageData* pDocPageData = m_pDocument->GetPageData();
477     if (pFormResources) {
478         m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pFormResources);
479     }
480     if (m_pColorSpace == NULL) {
481         m_pColorSpace = pDocPageData->GetColorSpace(pCSObj, pPageResources);
482     }
483     if (m_pColorSpace == NULL) {
484         return FALSE;
485     }
486     m_Family = m_pColorSpace->GetFamily();
487     m_nComponents = m_pColorSpace->CountComponents();
488     if (m_Family == PDFCS_ICCBASED && pCSObj->GetType() == PDFOBJ_NAME) {
489         CFX_ByteString cs = pCSObj->GetString();
490         if (cs == FX_BSTRC("DeviceGray")) {
491             m_nComponents = 1;
492         } else if (cs == FX_BSTRC("DeviceRGB")) {
493             m_nComponents = 3;
494         } else if (cs == FX_BSTRC("DeviceCMYK")) {
495             m_nComponents = 4;
496         }
497     }
498     ValidateDictParam();
499     m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
500     if (m_pCompData == NULL) {
501         return FALSE;
502     }
503     return TRUE;
504 }
505 DIB_COMP_DATA* CPDF_DIBSource::GetDecodeAndMaskArray(FX_BOOL& bDefaultDecode, FX_BOOL& bColorKey)
506 {
507     if (m_pColorSpace == NULL) {
508         return NULL;
509     }
510     DIB_COMP_DATA* pCompData = FX_Alloc(DIB_COMP_DATA, m_nComponents);
511     if (pCompData == NULL) {
512         return NULL;
513     }
514     int max_data = (1 << m_bpc) - 1;
515     CPDF_Array* pDecode = m_pDict->GetArray(FX_BSTRC("Decode"));
516     if (pDecode) {
517         for (FX_DWORD i = 0; i < m_nComponents; i ++) {
518             pCompData[i].m_DecodeMin = pDecode->GetNumber(i * 2);
519             FX_FLOAT max = pDecode->GetNumber(i * 2 + 1);
520             pCompData[i].m_DecodeStep = (max - pCompData[i].m_DecodeMin) / max_data;
521             FX_FLOAT def_value, def_min, def_max;
522             m_pColorSpace->GetDefaultValue(i, def_value, def_min, def_max);
523             if (m_Family == PDFCS_INDEXED) {
524                 def_max = (FX_FLOAT)max_data;
525             }
526             if (def_min != pCompData[i].m_DecodeMin || def_max != max) {
527                 bDefaultDecode = FALSE;
528             }
529         }
530     } else {
531         for (FX_DWORD i = 0; i < m_nComponents; i ++) {
532             FX_FLOAT def_value;
533             m_pColorSpace->GetDefaultValue(i, def_value, pCompData[i].m_DecodeMin, pCompData[i].m_DecodeStep);
534             if (m_Family == PDFCS_INDEXED) {
535                 pCompData[i].m_DecodeStep = (FX_FLOAT)max_data;
536             }
537             pCompData[i].m_DecodeStep = (pCompData[i].m_DecodeStep - pCompData[i].m_DecodeMin) / max_data;
538         }
539     }
540     if (!m_pDict->KeyExist(FX_BSTRC("SMask"))) {
541         CPDF_Object* pMask = m_pDict->GetElementValue(FX_BSTRC("Mask"));
542         if (pMask == NULL) {
543             return pCompData;
544         }
545         if (pMask->GetType() == PDFOBJ_ARRAY) {
546             CPDF_Array* pArray = (CPDF_Array*)pMask;
547             if (pArray->GetCount() >= m_nComponents * 2) {
548                 for (FX_DWORD i = 0; i < m_nComponents; i++) {
549                     int min_num = pArray->GetInteger(i * 2);
550                     int max_num = pArray->GetInteger(i * 2 + 1);
551                     pCompData[i].m_ColorKeyMin = FX_MAX(min_num, 0);
552                     pCompData[i].m_ColorKeyMax = FX_MIN(max_num, max_data);
553                 }
554             }
555             bColorKey = TRUE;
556         }
557     }
558     return pCompData;
559 }
560 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
561         const CPDF_Dictionary* pParams);
562 ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(FX_LPCBYTE src_buf, FX_DWORD src_size, int width, int height,
563         int nComps, int bpc, const CPDF_Dictionary* pParams);
564 int CPDF_DIBSource::CreateDecoder()
565 {
566     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
567     if (decoder.IsEmpty()) {
568         return 1;
569     }
570     if (m_bpc == 0) {
571         return 0;
572     }
573     FX_LPCBYTE src_data = m_pStreamAcc->GetData();
574     FX_DWORD src_size = m_pStreamAcc->GetSize();
575     const CPDF_Dictionary* pParams = m_pStreamAcc->GetImageParam();
576     if (decoder == FX_BSTRC("CCITTFaxDecode")) {
577         m_pDecoder = FPDFAPI_CreateFaxDecoder(src_data, src_size, m_Width, m_Height, pParams);
578     } else if (decoder == FX_BSTRC("DCTDecode")) {
579         m_pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(src_data, src_size, m_Width, m_Height,
580                      m_nComponents, pParams ? pParams->GetInteger(FX_BSTR("ColorTransform"), 1) : 1);
581         if (NULL == m_pDecoder) {
582             FX_BOOL bTransform = FALSE;
583             int comps, bpc;
584             ICodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
585             if (pJpegModule->LoadInfo(src_data, src_size, m_Width, m_Height, comps, bpc, bTransform)) {
586                 if (m_nComponents != comps) {
587                     FX_Free(m_pCompData);
588                     m_nComponents = comps;
589                     if (m_Family == PDFCS_LAB && m_nComponents != 3) {
590                         m_pCompData = NULL;
591                         return 0;
592                     }
593                     m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
594                     if (m_pCompData == NULL) {
595                         return 0;
596                     }
597                 }
598                 m_bpc = bpc;
599                 m_pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(src_data, src_size, m_Width, m_Height,
600                              m_nComponents, bTransform);
601             }
602         }
603     } else if (decoder == FX_BSTRC("FlateDecode")) {
604         m_pDecoder = FPDFAPI_CreateFlateDecoder(src_data, src_size, m_Width, m_Height, m_nComponents, m_bpc, pParams);
605     } else if (decoder == FX_BSTRC("JPXDecode")) {
606         LoadJpxBitmap();
607         return m_pCachedBitmap != NULL ? 1 : 0;
608     } else if (decoder == FX_BSTRC("JBIG2Decode")) {
609         m_pCachedBitmap = FX_NEW CFX_DIBitmap;
610         if (!m_pCachedBitmap->Create(m_Width, m_Height, m_bImageMask ? FXDIB_1bppMask : FXDIB_1bppRgb)) {
611             delete m_pCachedBitmap;
612             m_pCachedBitmap = NULL;
613             return 0;
614         }
615         m_Status = 1;
616         return 2;
617     } else if (decoder == FX_BSTRC("RunLengthDecode")) {
618         m_pDecoder = CPDF_ModuleMgr::Get()->GetCodecModule()->GetBasicModule()->CreateRunLengthDecoder(src_data, src_size, m_Width, m_Height, m_nComponents, m_bpc);
619     }
620     if (m_pDecoder) {
621         FX_SAFE_DWORD requested_pitch = m_bpc;
622         requested_pitch *= m_nComponents;
623         requested_pitch *= m_Width;
624         requested_pitch += 7;
625         requested_pitch /= 8;
626         if (!requested_pitch.IsValid()) {
627             return 0;
628         }
629         FX_SAFE_DWORD provided_pitch = m_pDecoder->GetBPC();
630         provided_pitch *= m_pDecoder->CountComps();
631         provided_pitch *= m_pDecoder->GetWidth();
632         provided_pitch += 7;
633         provided_pitch /= 8;
634         if (!provided_pitch.IsValid()) {
635             return 0;
636         }
637         if (provided_pitch.ValueOrDie() < requested_pitch.ValueOrDie()) {
638             return 0;
639         }
640         return 1;
641     }
642     return 0;
643 }
644 void CPDF_DIBSource::LoadJpxBitmap()
645 {
646     ICodec_JpxModule* pJpxModule = CPDF_ModuleMgr::Get()->GetJpxModule();
647     if (pJpxModule == NULL) {
648         return;
649     }
650     FX_LPVOID ctx = pJpxModule->CreateDecoder(m_pStreamAcc->GetData(), m_pStreamAcc->GetSize(), m_pColorSpace != NULL);
651     if (ctx == NULL) {
652         return;
653     }
654     FX_DWORD width = 0, height = 0, codestream_nComps = 0, image_nComps = 0;
655     pJpxModule->GetImageInfo(ctx, width, height, codestream_nComps, image_nComps);
656     if ((int)width < m_Width || (int)height < m_Height) {
657         pJpxModule->DestroyDecoder(ctx);
658         return;
659     }
660     int output_nComps;
661     FX_BOOL bTranslateColor, bSwapRGB = FALSE;
662     if (m_pColorSpace) {
663         if (codestream_nComps != (FX_DWORD)m_pColorSpace->CountComponents()) {
664             return;
665         }
666         output_nComps = codestream_nComps;
667         bTranslateColor = FALSE;
668         if (m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB)) {
669             bSwapRGB = TRUE;
670             m_pColorSpace = NULL;
671         }
672     } else {
673         bTranslateColor = TRUE;
674         if (image_nComps) {
675             output_nComps = image_nComps;
676         } else {
677             output_nComps = codestream_nComps;
678         }
679         if (output_nComps == 3) {
680             bSwapRGB = TRUE;
681         } else if (output_nComps == 4) {
682             m_pColorSpace = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
683             bTranslateColor = FALSE;
684         }
685         m_nComponents = output_nComps;
686     }
687     FXDIB_Format format;
688     if (output_nComps == 1) {
689         format = FXDIB_8bppRgb;
690     } else if (output_nComps <= 3) {
691         format = FXDIB_Rgb;
692     } else if (output_nComps == 4) {
693         format = FXDIB_Rgb32;
694     } else {
695         width = (width * output_nComps + 2) / 3;
696         format = FXDIB_Rgb;
697     }
698     m_pCachedBitmap = FX_NEW CFX_DIBitmap;
699     if (!m_pCachedBitmap->Create(width, height, format)) {
700         delete m_pCachedBitmap;
701         m_pCachedBitmap = NULL;
702         return;
703     }
704     m_pCachedBitmap->Clear(0xFFFFFFFF);
705     FX_LPBYTE output_offsets = FX_Alloc(FX_BYTE, output_nComps);
706     for (int i = 0; i < output_nComps; i ++) {
707         output_offsets[i] = i;
708     }
709     if (bSwapRGB) {
710         output_offsets[0] = 2;
711         output_offsets[2] = 0;
712     }
713     if (!pJpxModule->Decode(ctx, m_pCachedBitmap->GetBuffer(), m_pCachedBitmap->GetPitch(), bTranslateColor, output_offsets)) {
714         delete m_pCachedBitmap;
715         m_pCachedBitmap = NULL;
716         return;
717     }
718     FX_Free(output_offsets);
719     pJpxModule->DestroyDecoder(ctx);
720     if (m_pColorSpace && m_pColorSpace->GetFamily() == PDFCS_INDEXED && m_bpc < 8) {
721         int scale = 8 - m_bpc;
722         for (FX_DWORD row = 0; row < height; row ++) {
723             FX_LPBYTE scanline = (FX_LPBYTE)m_pCachedBitmap->GetScanline(row);
724             for (FX_DWORD col = 0; col < width; col ++) {
725                 *scanline = (*scanline) >> scale;
726                 scanline++;
727             }
728         }
729     }
730     m_bpc = 8;
731 }
732 void CPDF_DIBSource::LoadJbig2Bitmap()
733 {
734     ICodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
735     if (pJbig2Module == NULL) {
736         return;
737     }
738     CPDF_StreamAcc* pGlobalStream = NULL;
739     if (m_pStreamAcc->GetImageParam()) {
740         CPDF_Stream* pGlobals = m_pStreamAcc->GetImageParam()->GetStream(FX_BSTRC("JBIG2Globals"));
741         if (pGlobals) {
742             pGlobalStream = FX_NEW CPDF_StreamAcc;
743             pGlobalStream->LoadAllData(pGlobals, FALSE);
744         }
745     }
746     m_pCachedBitmap = FX_NEW CFX_DIBitmap;
747     if (!m_pCachedBitmap->Create(m_Width, m_Height, m_bImageMask ? FXDIB_1bppMask : FXDIB_1bppRgb)) {
748         return;
749     }
750     int ret = pJbig2Module->Decode(m_Width, m_Height, m_pStreamAcc->GetData(), m_pStreamAcc->GetSize(),
751                                    pGlobalStream ? pGlobalStream->GetData() : NULL, pGlobalStream ? pGlobalStream->GetSize() : 0,
752                                    m_pCachedBitmap->GetBuffer(), m_pCachedBitmap->GetPitch());
753     if (ret < 0) {
754         delete m_pCachedBitmap;
755         m_pCachedBitmap = NULL;
756     }
757     if (pGlobalStream) {
758         delete pGlobalStream;
759     }
760     m_bpc = 1;
761     m_nComponents = 1;
762 }
763 CPDF_DIBSource* CPDF_DIBSource::LoadMask(FX_DWORD& MatteColor)
764 {
765     MatteColor = 0xffffffff;
766     CPDF_Stream* pSoftMask = m_pDict->GetStream(FX_BSTRC("SMask"));
767     if (pSoftMask) {
768         CPDF_Array* pMatte = pSoftMask->GetDict()->GetArray(FX_BSTRC("Matte"));
769         if (pMatte != NULL && m_pColorSpace && (FX_DWORD)m_pColorSpace->CountComponents() <= m_nComponents) {
770             FX_FLOAT* pColor = FX_Alloc(FX_FLOAT, m_nComponents);
771             for (FX_DWORD i = 0; i < m_nComponents; i ++) {
772                 pColor[i] = pMatte->GetFloat(i);
773             }
774             FX_FLOAT R, G, B;
775             m_pColorSpace->GetRGB(pColor, R, G, B);
776             FX_Free(pColor);
777             MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255), FXSYS_round(B * 255));
778         }
779         return LoadMaskDIB(pSoftMask);
780     }
781     CPDF_Object* pMask = m_pDict->GetElementValue(FX_BSTRC("Mask"));
782     if (pMask == NULL) {
783         return NULL;
784     }
785     if (pMask->GetType() == PDFOBJ_STREAM) {
786         return LoadMaskDIB((CPDF_Stream*)pMask);
787     }
788     return NULL;
789 }
790 int     CPDF_DIBSource::StratLoadMask()
791 {
792     m_MatteColor = 0xffffffff;
793     m_pMaskStream = m_pDict->GetStream(FX_BSTRC("SMask"));
794     if (m_pMaskStream) {
795         CPDF_Array* pMatte = m_pMaskStream->GetDict()->GetArray(FX_BSTRC("Matte"));
796         if (pMatte != NULL && m_pColorSpace && (FX_DWORD)m_pColorSpace->CountComponents() <= m_nComponents) {
797             FX_FLOAT R, G, B;
798             FX_FLOAT* pColor = FX_Alloc(FX_FLOAT, m_nComponents);
799             for (FX_DWORD i = 0; i < m_nComponents; i ++) {
800                 pColor[i] = pMatte->GetFloat(i);
801             }
802             m_pColorSpace->GetRGB(pColor, R, G, B);
803             FX_Free(pColor);
804             m_MatteColor = FXARGB_MAKE(0, FXSYS_round(R * 255), FXSYS_round(G * 255), FXSYS_round(B * 255));
805         }
806         return StartLoadMaskDIB();
807     }
808     m_pMaskStream = m_pDict->GetElementValue(FX_BSTRC("Mask"));
809     if (m_pMaskStream == NULL) {
810         return 1;
811     }
812     if (m_pMaskStream->GetType() == PDFOBJ_STREAM) {
813         return StartLoadMaskDIB();
814     }
815     return 1;
816 }
817 int     CPDF_DIBSource::ContinueLoadMaskDIB(IFX_Pause* pPause)
818 {
819     if (m_pMask == NULL) {
820         return 1;
821     }
822     int ret = m_pMask->ContinueLoadDIBSource(pPause);
823     if (ret == 2) {
824         return ret;
825     }
826     if (m_pColorSpace && m_bStdCS) {
827         m_pColorSpace->EnableStdConversion(FALSE);
828     }
829     if (!ret) {
830         delete m_pMask;
831         m_pMask = NULL;
832         return ret;
833     }
834     return 1;
835 }
836 CPDF_DIBSource* CPDF_DIBSource::DetachMask()
837 {
838     CPDF_DIBSource* pDIBSource = m_pMask;
839     m_pMask = NULL;
840     return pDIBSource;
841 }
842 CPDF_DIBSource* CPDF_DIBSource::LoadMaskDIB(CPDF_Stream* pMask)
843 {
844     CPDF_DIBSource* pMaskSource = FX_NEW CPDF_DIBSource;
845     if (!pMaskSource->Load(m_pDocument, pMask, NULL, NULL, NULL, NULL, TRUE)) {
846         delete pMaskSource;
847         return NULL;
848     }
849     return pMaskSource;
850 }
851 int CPDF_DIBSource::StartLoadMaskDIB()
852 {
853     m_pMask = FX_NEW CPDF_DIBSource;
854     int ret = m_pMask->StartLoadDIBSource(m_pDocument, (CPDF_Stream*)m_pMaskStream, FALSE, NULL, NULL, TRUE);
855     if (ret == 2) {
856         if (m_Status == 0) {
857             m_Status = 2;
858         }
859         return 2;
860     }
861     if (!ret) {
862         delete m_pMask;
863         m_pMask = NULL;
864         return 1;
865     }
866     return 1;
867 }
868 void CPDF_DIBSource::LoadPalette()
869 {
870     if (m_bpc == 0) {
871         return;
872     }
873     if (m_bpc * m_nComponents > 8) {
874         return;
875     }
876     if (m_pColorSpace == NULL) {
877         return;
878     }
879     if (m_bpc * m_nComponents == 1) {
880         if (m_bDefaultDecode && (m_Family == PDFCS_DEVICEGRAY || m_Family == PDFCS_DEVICERGB)) {
881             return;
882         }
883         if (m_pColorSpace->CountComponents() > 3) {
884             return;
885         }
886         FX_FLOAT color_values[3];
887         color_values[0] = m_pCompData[0].m_DecodeMin;
888         color_values[1] = color_values[2] = color_values[0];
889         FX_FLOAT R=0.0f, G=0.0f, B=0.0f;
890         m_pColorSpace->GetRGB(color_values, R, G, B);
891         FX_ARGB argb0 = ArgbEncode(255, FXSYS_round(R * 255), FXSYS_round(G * 255), FXSYS_round(B * 255));
892         color_values[0] += m_pCompData[0].m_DecodeStep;
893         color_values[1] += m_pCompData[0].m_DecodeStep;
894         color_values[2] += m_pCompData[0].m_DecodeStep;
895         m_pColorSpace->GetRGB(color_values, R, G, B);
896         FX_ARGB argb1 = ArgbEncode(255, FXSYS_round(R * 255), FXSYS_round(G * 255), FXSYS_round(B * 255));
897         if (argb0 != 0xFF000000 || argb1 != 0xFFFFFFFF) {
898             SetPaletteArgb(0, argb0);
899             SetPaletteArgb(1, argb1);
900         }
901         return;
902     }
903     if (m_pColorSpace == CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY) && m_bpc == 8 && m_bDefaultDecode) {
904     } else {
905         int palette_count = 1 << (m_bpc * m_nComponents);
906         CFX_FixedBufGrow<FX_FLOAT, 16> color_values(m_nComponents);
907         FX_FLOAT* color_value = color_values;
908         for (int i = 0; i < palette_count; i ++) {
909             int color_data = i;
910             for (FX_DWORD j = 0; j < m_nComponents; j ++) {
911                 int encoded_component = color_data % (1 << m_bpc);
912                 color_data /= 1 << m_bpc;
913                 color_value[j] = m_pCompData[j].m_DecodeMin + m_pCompData[j].m_DecodeStep * encoded_component;
914             }
915             FX_FLOAT R = 0, G = 0, B = 0;
916             if (m_nComponents == 1 && m_Family == PDFCS_ICCBASED && m_pColorSpace->CountComponents() > 1) {
917                 int nComponents = m_pColorSpace->CountComponents();
918                 FX_FLOAT* temp_buf = FX_Alloc(FX_FLOAT, nComponents);
919                 for (int i = 0; i < nComponents; i++) {
920                     temp_buf[i] = *color_value;
921                 }
922                 m_pColorSpace->GetRGB(temp_buf, R, G, B);
923                 FX_Free(temp_buf);
924             } else {
925                 m_pColorSpace->GetRGB(color_value, R, G, B);
926             }
927             SetPaletteArgb(i, ArgbEncode(255, FXSYS_round(R * 255), FXSYS_round(G * 255), FXSYS_round(B * 255)));
928         }
929     }
930 }
931 void CPDF_DIBSource::ValidateDictParam()
932 {
933     m_bpc = m_bpc_orig;
934         CPDF_Object * pFilter = m_pDict->GetElementValue(FX_BSTRC("Filter"));
935     if (pFilter) {
936         if (pFilter->GetType() == PDFOBJ_NAME) {
937             CFX_ByteString filter = pFilter->GetString();
938             if (filter == FX_BSTRC("CCITTFaxDecode") || filter == FX_BSTRC("JBIG2Decode")) {
939                 m_bpc = 1;
940                 m_nComponents = 1;
941             }
942             if (filter == FX_BSTRC("RunLengthDecode") || filter == FX_BSTRC("DCTDecode")) {
943                 m_bpc = 8;
944             }
945         } else if (pFilter->GetType() == PDFOBJ_ARRAY) {
946             CPDF_Array *pArray = (CPDF_Array *)pFilter;
947             if (pArray->GetString(pArray->GetCount() - 1) == FX_BSTRC("CCITTFacDecode") ||
948                     pArray->GetString(pArray->GetCount() - 1) == FX_BSTRC("JBIG2Decode")) {
949                 m_bpc = 1;
950                 m_nComponents = 1;
951             }
952             if (pArray->GetString(pArray->GetCount() - 1) == FX_BSTRC("DCTDecode")) {
953                 // Previously, pArray->GetString(pArray->GetCount() - 1) == FX_BSTRC("RunLengthDecode") was checked in the "if" statement as well,
954                 // but too many documents don't conform to it.
955                 m_bpc = 8;
956             }
957         }
958     }
959     if (m_bpc != 1 && m_bpc != 2 && m_bpc != 4 && m_bpc != 8 && m_bpc != 16) {
960         m_bpc = 0;
961     }
962 }
963 #define NORMALCOLOR_MAX(color, max) (color) > (max) ? (max) : (color) < 0 ? 0 : (color);
964 void CPDF_DIBSource::TranslateScanline24bpp(FX_LPBYTE dest_scan, FX_LPCBYTE src_scan) const
965 {
966     if (m_bpc == 0) {
967         return;
968     }
969     int max_data = (1 << m_bpc) - 1;
970     if (m_bDefaultDecode) {
971         if (m_Family == PDFCS_DEVICERGB || m_Family == PDFCS_CALRGB) {
972             FX_LPCBYTE src_pos = src_scan;
973             switch (m_bpc) {
974                 case 16:
975                     for (int col = 0; col < m_Width; col ++) {
976                         *dest_scan++ = src_pos[4];
977                         *dest_scan++ = src_pos[2];
978                         *dest_scan++ = *src_pos;
979                         src_pos += 6;
980                     }
981                     break;
982                 case 8:
983                     for (int column = 0; column < m_Width; column ++) {
984                         *dest_scan++ = src_pos[2];
985                         *dest_scan++ = src_pos[1];
986                         *dest_scan++ = *src_pos;
987                         src_pos += 3;
988                     }
989                     break;
990                 default:
991                     int src_bit_pos = 0;
992                     int dest_byte_pos = 0;
993                     for (int column = 0; column < m_Width; column ++) {
994                         int R = _GetBits8(src_scan, src_bit_pos, m_bpc);
995                         src_bit_pos += m_bpc;
996                         int G = _GetBits8(src_scan, src_bit_pos, m_bpc);
997                         src_bit_pos += m_bpc;
998                         int B = _GetBits8(src_scan, src_bit_pos, m_bpc);
999                         src_bit_pos += m_bpc;
1000                         R = NORMALCOLOR_MAX(R, max_data);
1001                         G = NORMALCOLOR_MAX(G, max_data);
1002                         B = NORMALCOLOR_MAX(B, max_data);
1003                         dest_scan[dest_byte_pos] = B * 255 / max_data;
1004                         dest_scan[dest_byte_pos + 1] = G * 255 / max_data;
1005                         dest_scan[dest_byte_pos + 2] = R * 255 / max_data;
1006                         dest_byte_pos += 3;
1007                     }
1008                     break;
1009             }
1010             return;
1011         } else if (m_bpc == 8) {
1012             if (m_nComponents == m_pColorSpace->CountComponents())
1013                 m_pColorSpace->TranslateImageLine(dest_scan, src_scan, m_Width, m_Width, m_Height,
1014                                                   m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK && m_Family == PDFCS_DEVICECMYK);
1015             return;
1016         }
1017     }
1018     CFX_FixedBufGrow<FX_FLOAT, 16> color_values1(m_nComponents);
1019     FX_FLOAT* color_values = color_values1;
1020     FX_FLOAT R = 0.0f, G = 0.0f, B = 0.0f;
1021     if (m_bpc == 8) {
1022         int src_byte_pos = 0;
1023         int dest_byte_pos = 0;
1024         for (int column = 0; column < m_Width; column ++) {
1025             for (FX_DWORD color = 0; color < m_nComponents; color ++) {
1026                 int data = src_scan[src_byte_pos ++];
1027                 color_values[color] = m_pCompData[color].m_DecodeMin +
1028                                       m_pCompData[color].m_DecodeStep * data;
1029             }
1030             if (m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK && m_Family == PDFCS_DEVICECMYK) {
1031                 FX_FLOAT k = 1.0f - color_values[3];
1032                 R = (1.0f - color_values[0]) * k;
1033                 G = (1.0f - color_values[1]) * k;
1034                 B = (1.0f - color_values[2]) * k;
1035             } else {
1036                 m_pColorSpace->GetRGB(color_values, R, G, B);
1037             }
1038             R = NORMALCOLOR_MAX(R, 1);
1039             G = NORMALCOLOR_MAX(G, 1);
1040             B = NORMALCOLOR_MAX(B, 1);
1041             dest_scan[dest_byte_pos] = (FX_INT32)(B * 255);
1042             dest_scan[dest_byte_pos + 1] = (FX_INT32)(G * 255);
1043             dest_scan[dest_byte_pos + 2] = (FX_INT32)(R * 255);
1044             dest_byte_pos += 3;
1045         }
1046     } else {
1047         int src_bit_pos = 0;
1048         int dest_byte_pos = 0;
1049         for (int column = 0; column < m_Width; column ++) {
1050             for (FX_DWORD color = 0; color < m_nComponents; color ++) {
1051                 int data = _GetBits8(src_scan, src_bit_pos, m_bpc);
1052                 color_values[color] = m_pCompData[color].m_DecodeMin +
1053                                       m_pCompData[color].m_DecodeStep * data;
1054                 src_bit_pos += m_bpc;
1055             }
1056             if (m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK && m_Family == PDFCS_DEVICECMYK) {
1057                 FX_FLOAT k = 1.0f - color_values[3];
1058                 R = (1.0f - color_values[0]) * k;
1059                 G = (1.0f - color_values[1]) * k;
1060                 B = (1.0f - color_values[2]) * k;
1061             } else {
1062                 m_pColorSpace->GetRGB(color_values, R, G, B);
1063             }
1064             R = NORMALCOLOR_MAX(R, 1);
1065             G = NORMALCOLOR_MAX(G, 1);
1066             B = NORMALCOLOR_MAX(B, 1);
1067             dest_scan[dest_byte_pos] = (FX_INT32)(B * 255);
1068             dest_scan[dest_byte_pos + 1] = (FX_INT32)(G * 255);
1069             dest_scan[dest_byte_pos + 2] = (FX_INT32)(R * 255);
1070             dest_byte_pos += 3;
1071         }
1072     }
1073 }
1074 FX_LPBYTE CPDF_DIBSource::GetBuffer() const
1075 {
1076     if (m_pCachedBitmap) {
1077         return m_pCachedBitmap->GetBuffer();
1078     }
1079     return NULL;
1080 }
1081 FX_LPCBYTE CPDF_DIBSource::GetScanline(int line) const
1082 {
1083     if (m_bpc == 0) {
1084         return NULL;
1085     }
1086     FX_SAFE_DWORD src_pitch = m_Width;
1087     src_pitch *= m_bpc;
1088     src_pitch *= m_nComponents;
1089     src_pitch += 7;
1090     src_pitch /= 8;
1091     if (!src_pitch.IsValid())
1092         return NULL;
1093     FX_DWORD src_pitch_value = src_pitch.ValueOrDie();
1094     FX_LPCBYTE pSrcLine = NULL;
1095     if (m_pCachedBitmap) {
1096         if (line >= m_pCachedBitmap->GetHeight()) {
1097             line = m_pCachedBitmap->GetHeight() - 1;
1098         }
1099         pSrcLine = m_pCachedBitmap->GetScanline(line);
1100     } else if (m_pDecoder) {
1101         pSrcLine = m_pDecoder->GetScanline(line);
1102     } else {
1103         if (m_pStreamAcc->GetSize() >= (line + 1) * src_pitch_value) {
1104             pSrcLine = m_pStreamAcc->GetData() + line * src_pitch_value;
1105         }
1106     }
1107     if (pSrcLine == NULL) {
1108         FX_LPBYTE pLineBuf = m_pMaskedLine ? m_pMaskedLine : m_pLineBuf;
1109         FXSYS_memset8(pLineBuf, 0xff, m_Pitch);
1110         return pLineBuf;
1111     }
1112     if (m_bpc * m_nComponents == 1) {
1113         if (m_bImageMask && m_bDefaultDecode) {
1114             for (FX_DWORD i = 0; i < src_pitch_value; i++) {
1115                 m_pLineBuf[i] = ~pSrcLine[i];
1116             }
1117         } else if (m_bColorKey) {
1118             FX_DWORD reset_argb, set_argb;
1119             reset_argb = m_pPalette ? m_pPalette[0] : 0xff000000;
1120             set_argb = m_pPalette ? m_pPalette[1] : 0xffffffff;
1121             if (m_pCompData[0].m_ColorKeyMin == 0) {
1122                 reset_argb = 0;
1123             }
1124             if (m_pCompData[0].m_ColorKeyMax == 1) {
1125                 set_argb = 0;
1126             }
1127             set_argb = FXARGB_TODIB(set_argb);
1128             reset_argb = FXARGB_TODIB(reset_argb);
1129             FX_DWORD* dest_scan = (FX_DWORD*)m_pMaskedLine;
1130             for (int col = 0; col < m_Width; col ++) {
1131                 if (pSrcLine[col / 8] & (1 << (7 - col % 8))) {
1132                     *dest_scan = set_argb;
1133                 } else {
1134                     *dest_scan = reset_argb;
1135                 }
1136                 dest_scan ++;
1137             }
1138             return m_pMaskedLine;
1139         } else {
1140             FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch_value);
1141         }
1142         return m_pLineBuf;
1143     }
1144     if (m_bpc * m_nComponents <= 8) {
1145         if (m_bpc == 8) {
1146             FXSYS_memcpy32(m_pLineBuf, pSrcLine, src_pitch_value);
1147         } else {
1148             int src_bit_pos = 0;
1149             for (int col = 0; col < m_Width; col ++) {
1150                 int color_index = 0;
1151                 for (FX_DWORD color = 0; color < m_nComponents; color ++) {
1152                     int data = _GetBits8(pSrcLine, src_bit_pos, m_bpc);
1153                     color_index |= data << (color * m_bpc);
1154                     src_bit_pos += m_bpc;
1155                 }
1156                 m_pLineBuf[col] = color_index;
1157             }
1158         }
1159         if (m_bColorKey) {
1160             FX_LPBYTE pDestPixel = m_pMaskedLine;
1161             FX_LPCBYTE pSrcPixel = m_pLineBuf;
1162             for (int col = 0; col < m_Width; col ++) {
1163                 FX_BYTE index = *pSrcPixel++;
1164                 if (m_pPalette) {
1165                     *pDestPixel++ = FXARGB_B(m_pPalette[index]);
1166                     *pDestPixel++ = FXARGB_G(m_pPalette[index]);
1167                     *pDestPixel++ = FXARGB_R(m_pPalette[index]);
1168                 } else {
1169                     *pDestPixel++ = index;
1170                     *pDestPixel++ = index;
1171                     *pDestPixel++ = index;
1172                 }
1173                 *pDestPixel = (index < m_pCompData[0].m_ColorKeyMin || index > m_pCompData[0].m_ColorKeyMax) ? 0xff : 0;
1174                 pDestPixel ++ ;
1175             }
1176             return m_pMaskedLine;
1177         }
1178         return m_pLineBuf;
1179     }
1180     if (m_bColorKey) {
1181         if (m_nComponents == 3 && m_bpc == 8) {
1182             FX_LPBYTE alpha_channel = m_pMaskedLine + 3;
1183             for (int col = 0; col < m_Width; col ++) {
1184                 FX_LPCBYTE pPixel = pSrcLine + col * 3;
1185                 alpha_channel[col * 4] = (pPixel[0] < m_pCompData[0].m_ColorKeyMin || pPixel[0] > m_pCompData[0].m_ColorKeyMax ||
1186                                           pPixel[1] < m_pCompData[1].m_ColorKeyMin || pPixel[1] > m_pCompData[1].m_ColorKeyMax ||
1187                                           pPixel[2] < m_pCompData[2].m_ColorKeyMin || pPixel[2] > m_pCompData[2].m_ColorKeyMax) ? 0xff : 0;
1188             }
1189         } else {
1190             FXSYS_memset8(m_pMaskedLine, 0xff, m_Pitch);
1191         }
1192     }
1193     if (m_pColorSpace) {
1194         TranslateScanline24bpp(m_pLineBuf, pSrcLine);
1195         pSrcLine = m_pLineBuf;
1196     }
1197     if (m_bColorKey) {
1198         FX_LPCBYTE pSrcPixel = pSrcLine;
1199         FX_LPBYTE pDestPixel = m_pMaskedLine;
1200         for (int col = 0; col < m_Width; col ++) {
1201             *pDestPixel++ = *pSrcPixel++;
1202             *pDestPixel++ = *pSrcPixel++;
1203             *pDestPixel++ = *pSrcPixel++;
1204             pDestPixel ++;
1205         }
1206         return m_pMaskedLine;
1207     }
1208     return pSrcLine;
1209 }
1210 FX_BOOL CPDF_DIBSource::SkipToScanline(int line, IFX_Pause* pPause) const
1211 {
1212     if (m_pDecoder) {
1213         return m_pDecoder->SkipToScanline(line, pPause);
1214     }
1215     return FALSE;
1216 }
1217 void CPDF_DIBSource::DownSampleScanline(int line, FX_LPBYTE dest_scan, int dest_bpp,
1218                                         int dest_width, FX_BOOL bFlipX, int clip_left, int clip_width) const
1219 {
1220     if (line < 0 || dest_scan == NULL || dest_bpp <= 0 ||
1221         dest_width <= 0 || clip_left < 0 || clip_width <= 0) {
1222         return;
1223     }
1224
1225     FX_DWORD src_width = m_Width;
1226     FX_SAFE_DWORD pitch = src_width;
1227     pitch *= m_bpc;
1228     pitch *= m_nComponents;
1229     pitch += 7;
1230     pitch /= 8;
1231     if (!pitch.IsValid()) { 
1232         return;
1233     }
1234
1235     FX_LPCBYTE pSrcLine = NULL;
1236     if (m_pCachedBitmap) {
1237         pSrcLine = m_pCachedBitmap->GetScanline(line);
1238     } else if (m_pDecoder) {
1239         pSrcLine = m_pDecoder->GetScanline(line);
1240     } else {
1241         FX_DWORD src_pitch = pitch.ValueOrDie();
1242         pitch *= (line+1);
1243         if (!pitch.IsValid()) { 
1244             return;
1245         }
1246  
1247         if (m_pStreamAcc->GetSize() >= pitch.ValueOrDie()) {
1248             pSrcLine = m_pStreamAcc->GetData() + line * src_pitch;
1249         }
1250     }
1251     int orig_Bpp = m_bpc * m_nComponents / 8;
1252     int dest_Bpp = dest_bpp / 8;
1253     if (pSrcLine == NULL) {
1254         FXSYS_memset32(dest_scan, 0xff, dest_Bpp * clip_width);
1255         return;
1256     }
1257
1258     FX_SAFE_INT32 max_src_x = clip_left;
1259     max_src_x += clip_width - 1;
1260     max_src_x *= src_width;
1261     max_src_x /= dest_width;
1262     if (!max_src_x.IsValid()) {
1263         return;
1264     }
1265
1266     CFX_FixedBufGrow<FX_BYTE, 128> temp(orig_Bpp);
1267     if (m_bpc * m_nComponents == 1) {
1268         FX_DWORD set_argb = (FX_DWORD) - 1, reset_argb = 0;
1269         if (m_bImageMask) {
1270             if (m_bDefaultDecode) {
1271                 set_argb = 0;
1272                 reset_argb = (FX_DWORD) - 1;
1273             }
1274         } else if (m_bColorKey) {
1275             reset_argb = m_pPalette ? m_pPalette[0] : 0xff000000;
1276             set_argb = m_pPalette ? m_pPalette[1] : 0xffffffff;
1277             if (m_pCompData[0].m_ColorKeyMin == 0) {
1278                 reset_argb = 0;
1279             }
1280             if (m_pCompData[0].m_ColorKeyMax == 1) {
1281                 set_argb = 0;
1282             }
1283             set_argb = FXARGB_TODIB(set_argb);
1284             reset_argb = FXARGB_TODIB(reset_argb);
1285             for (int i = 0; i < clip_width; i ++) {
1286                 FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
1287                 if (bFlipX) {
1288                     src_x = src_width - src_x - 1;
1289                 }
1290                 src_x %= src_width;
1291                 if (pSrcLine[src_x / 8] & (1 << (7 - src_x % 8))) {
1292                     ((FX_DWORD*)dest_scan)[i] = set_argb;
1293                 } else {
1294                     ((FX_DWORD*)dest_scan)[i] = reset_argb;
1295                 }
1296             }
1297             return;
1298         } else {
1299             if (dest_Bpp == 1) {
1300             } else if (m_pPalette) {
1301                 reset_argb = m_pPalette[0];
1302                 set_argb = m_pPalette[1];
1303             }
1304         }
1305         for (int i = 0; i < clip_width; i ++) {
1306             FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
1307             if (bFlipX) {
1308                 src_x = src_width - src_x - 1;
1309             }
1310             src_x %= src_width;
1311             int dest_pos = i * dest_Bpp;
1312             if (pSrcLine[src_x / 8] & (1 << (7 - src_x % 8))) {
1313                 if (dest_Bpp == 1) {
1314                     dest_scan[dest_pos] = (FX_BYTE)set_argb;
1315                 } else if (dest_Bpp == 3) {
1316                     dest_scan[dest_pos] = FXARGB_B(set_argb);
1317                     dest_scan[dest_pos + 1] = FXARGB_G(set_argb);
1318                     dest_scan[dest_pos + 2] = FXARGB_R(set_argb);
1319                 } else {
1320                     *(FX_DWORD*)(dest_scan + dest_pos) = set_argb;
1321                 }
1322             } else {
1323                 if (dest_Bpp == 1) {
1324                     dest_scan[dest_pos] = (FX_BYTE)reset_argb;
1325                 } else if (dest_Bpp == 3) {
1326                     dest_scan[dest_pos] = FXARGB_B(reset_argb);
1327                     dest_scan[dest_pos + 1] = FXARGB_G(reset_argb);
1328                     dest_scan[dest_pos + 2] = FXARGB_R(reset_argb);
1329                 } else {
1330                     *(FX_DWORD*)(dest_scan + dest_pos) = reset_argb;
1331                 }
1332             }
1333         }
1334         return;
1335     } else if (m_bpc * m_nComponents <= 8) {
1336         if (m_bpc < 8) {
1337             int src_bit_pos = 0;
1338             for (FX_DWORD col = 0; col < src_width; col ++) {
1339                 int color_index = 0;
1340                 for (FX_DWORD color = 0; color < m_nComponents; color ++) {
1341                     int data = _GetBits8(pSrcLine, src_bit_pos, m_bpc);
1342                     color_index |= data << (color * m_bpc);
1343                     src_bit_pos += m_bpc;
1344                 }
1345                 m_pLineBuf[col] = color_index;
1346             }
1347             pSrcLine = m_pLineBuf;
1348         }
1349         if (m_bColorKey) {
1350             for (int i = 0; i < clip_width; i ++) {
1351                 FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
1352                 if (bFlipX) {
1353                     src_x = src_width - src_x - 1;
1354                 }
1355                 src_x %= src_width;
1356                 FX_LPBYTE pDestPixel = dest_scan + i * 4;
1357                 FX_BYTE index = pSrcLine[src_x];
1358                 if (m_pPalette) {
1359                     *pDestPixel++ = FXARGB_B(m_pPalette[index]);
1360                     *pDestPixel++ = FXARGB_G(m_pPalette[index]);
1361                     *pDestPixel++ = FXARGB_R(m_pPalette[index]);
1362                 } else {
1363                     *pDestPixel++ = index;
1364                     *pDestPixel++ = index;
1365                     *pDestPixel++ = index;
1366                 }
1367                 *pDestPixel = (index < m_pCompData[0].m_ColorKeyMin || index > m_pCompData[0].m_ColorKeyMax) ? 0xff : 0;
1368             }
1369             return;
1370         }
1371         for (int i = 0; i < clip_width; i ++) {
1372             FX_DWORD src_x = (clip_left + i) * src_width / dest_width;
1373             if (bFlipX) {
1374                 src_x = src_width - src_x - 1;
1375             }
1376             src_x %= src_width;
1377             FX_BYTE index = pSrcLine[src_x];
1378             if (dest_Bpp == 1) {
1379                 dest_scan[i] = index;
1380             } else {
1381                 int dest_pos = i * dest_Bpp;
1382                 FX_ARGB argb = m_pPalette[index];
1383                 dest_scan[dest_pos] = FXARGB_B(argb);
1384                 dest_scan[dest_pos + 1] = FXARGB_G(argb);
1385                 dest_scan[dest_pos + 2] = FXARGB_R(argb);
1386             }
1387         }
1388         return;
1389     } else {
1390         int last_src_x = -1;
1391         FX_ARGB last_argb;
1392         FX_FLOAT orig_Not8Bpp = (FX_FLOAT)m_bpc * (FX_FLOAT)m_nComponents / 8.0f;
1393         FX_FLOAT unit_To8Bpc = 255.0f / ((1 << m_bpc) - 1);
1394         for (int i = 0; i < clip_width; i ++) {
1395             int dest_x = clip_left + i;
1396             FX_DWORD src_x = (bFlipX ? (dest_width - dest_x - 1) : dest_x) * (FX_INT64)src_width / dest_width;
1397             src_x %= src_width;
1398             FX_LPCBYTE pSrcPixel = NULL;
1399             if (m_bpc % 8 == 0) {
1400                 pSrcPixel = pSrcLine + src_x * orig_Bpp;
1401             } else {
1402                 pSrcPixel = pSrcLine + (int)(src_x * orig_Not8Bpp);
1403             }
1404             FX_LPBYTE pDestPixel = dest_scan + i * dest_Bpp;
1405             FX_ARGB argb;
1406             if (src_x == last_src_x) {
1407                 argb = last_argb;
1408             } else {
1409                 if (m_pColorSpace) {
1410                     FX_BYTE color[4];
1411                     if (!m_bDefaultDecode) {
1412                         for (int i = 0; i < m_nComponents; i ++) {
1413                             int color_value = (int)((m_pCompData[i].m_DecodeMin + m_pCompData[i].m_DecodeStep * (FX_FLOAT)pSrcPixel[i]) * 255.0f + 0.5f);
1414                             temp[i] = color_value > 255 ? 255 : (color_value < 0 ? 0 : color_value);
1415                         }
1416                         m_pColorSpace->TranslateImageLine(color, temp, 1, 0, 0, m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK && m_Family == PDFCS_DEVICECMYK);
1417                     } else {
1418                         if (m_bpc < 8) {
1419                             int src_bit_pos = 0;
1420                             if (src_x % 2) {
1421                                 src_bit_pos = 4;
1422                             }
1423                             for (FX_DWORD i = 0; i < m_nComponents; i ++) {
1424                                 temp[i] = (FX_BYTE)(_GetBits8(pSrcPixel, src_bit_pos, m_bpc) * unit_To8Bpc);
1425                                 src_bit_pos += m_bpc;
1426                             }
1427                             m_pColorSpace->TranslateImageLine(color, temp, 1, 0, 0, m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK && m_Family == PDFCS_DEVICECMYK);
1428                         } else {
1429                             m_pColorSpace->TranslateImageLine(color, pSrcPixel, 1, 0, 0, m_bLoadMask && m_GroupFamily == PDFCS_DEVICECMYK && m_Family == PDFCS_DEVICECMYK);
1430                         }
1431                     }
1432                     argb = FXARGB_MAKE(0xff, color[2], color[1], color[0]);
1433                 } else {
1434                     argb = FXARGB_MAKE(0xff, pSrcPixel[2], pSrcPixel[1], pSrcPixel[0]);
1435                 }
1436                 if (m_bColorKey) {
1437                     int alpha = 0xff;
1438                     if (m_nComponents == 3 && m_bpc == 8) {
1439                         alpha = (pSrcPixel[0] < m_pCompData[0].m_ColorKeyMin ||
1440                                  pSrcPixel[0] > m_pCompData[0].m_ColorKeyMax ||
1441                                  pSrcPixel[1] < m_pCompData[1].m_ColorKeyMin ||
1442                                  pSrcPixel[1] > m_pCompData[1].m_ColorKeyMax ||
1443                                  pSrcPixel[2] < m_pCompData[2].m_ColorKeyMin ||
1444                                  pSrcPixel[2] > m_pCompData[2].m_ColorKeyMax) ? 0xff : 0;
1445                     }
1446                     argb &= 0xffffff;
1447                     argb |= alpha << 24;
1448                 }
1449                 last_src_x = src_x;
1450                 last_argb = argb;
1451             }
1452             if (dest_Bpp == 4) {
1453                 *(FX_DWORD*)pDestPixel = FXARGB_TODIB(argb);
1454             } else {
1455                 *pDestPixel++ = FXARGB_B(argb);
1456                 *pDestPixel++ = FXARGB_G(argb);
1457                 *pDestPixel = FXARGB_R(argb);
1458             }
1459         }
1460     }
1461 }
1462 void CPDF_DIBSource::SetDownSampleSize(int dest_width, int dest_height) const
1463 {
1464     if (m_pDecoder) {
1465         m_pDecoder->DownScale(dest_width, dest_height);
1466         ((CPDF_DIBSource*)this)->m_Width = m_pDecoder->GetWidth();
1467         ((CPDF_DIBSource*)this)->m_Height = m_pDecoder->GetHeight();
1468     }
1469 }
1470 void CPDF_DIBSource::ClearImageData()
1471 {
1472     if (m_pDecoder) {
1473         m_pDecoder->ClearImageData();
1474     }
1475 }
1476 CPDF_ProgressiveImageLoaderHandle::CPDF_ProgressiveImageLoaderHandle()
1477 {
1478     m_pImageLoader = NULL;
1479     m_pCache = NULL;
1480     m_pImage = NULL;
1481 }
1482 CPDF_ProgressiveImageLoaderHandle::~CPDF_ProgressiveImageLoaderHandle()
1483 {
1484     m_pImageLoader = NULL;
1485     m_pCache = NULL;
1486     m_pImage = NULL;
1487 }
1488 FX_BOOL CPDF_ProgressiveImageLoaderHandle::Start(CPDF_ImageLoader* pImageLoader, const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus, FX_INT32 nDownsampleWidth, FX_INT32 nDownsampleHeight)
1489 {
1490     m_pImageLoader = pImageLoader;
1491     m_pCache = pCache;
1492     m_pImage = (CPDF_ImageObject*)pImage;
1493     m_nDownsampleWidth = nDownsampleWidth;
1494     m_nDownsampleHeight = nDownsampleHeight;
1495     FX_BOOL ret;
1496     if (pCache) {
1497         ret = pCache->StartGetCachedBitmap(pImage->m_pImage->GetStream(), bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
1498         if (ret == FALSE) {
1499             m_pImageLoader->m_bCached = TRUE;
1500             m_pImageLoader->m_pBitmap = pCache->m_pCurImageCache->DetachBitmap();
1501             m_pImageLoader->m_pMask = pCache->m_pCurImageCache->DetachMask();
1502             m_pImageLoader->m_MatteColor = pCache->m_pCurImageCache->m_MatteColor;
1503         }
1504     } else {
1505         ret = pImage->m_pImage->StartLoadDIBSource(pRenderStatus->m_pFormResource, pRenderStatus->m_pPageResource, bStdCS, GroupFamily, bLoadMask);
1506         if (ret == FALSE) {
1507             m_pImageLoader->m_bCached = FALSE;
1508             m_pImageLoader->m_pBitmap = m_pImage->m_pImage->DetachBitmap();
1509             m_pImageLoader->m_pMask = m_pImage->m_pImage->DetachMask();
1510             m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
1511         }
1512     }
1513     return ret;
1514 }
1515 FX_BOOL CPDF_ProgressiveImageLoaderHandle::Continue(IFX_Pause* pPause)
1516 {
1517     FX_BOOL ret;
1518     if (m_pCache) {
1519         ret = m_pCache->Continue(pPause);
1520         if (ret == FALSE) {
1521             m_pImageLoader->m_bCached = TRUE;
1522             m_pImageLoader->m_pBitmap = m_pCache->m_pCurImageCache->DetachBitmap();
1523             m_pImageLoader->m_pMask = m_pCache->m_pCurImageCache->DetachMask();
1524             m_pImageLoader->m_MatteColor = m_pCache->m_pCurImageCache->m_MatteColor;
1525         }
1526     } else {
1527         ret = m_pImage->m_pImage->Continue(pPause);
1528         if (ret == FALSE) {
1529             m_pImageLoader->m_bCached = FALSE;
1530             m_pImageLoader->m_pBitmap = m_pImage->m_pImage->DetachBitmap();
1531             m_pImageLoader->m_pMask = m_pImage->m_pImage->DetachMask();
1532             m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
1533         }
1534     }
1535     return ret;
1536 }
1537 FX_BOOL CPDF_ImageLoader::Load(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus)
1538 {
1539     if (pImage == NULL) {
1540         return FALSE;
1541     }
1542     if (pCache) {
1543         pCache->GetCachedBitmap(pImage->m_pImage->GetStream(), m_pBitmap, m_pMask, m_MatteColor, bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
1544         m_bCached = TRUE;
1545     } else {
1546         m_pBitmap = pImage->m_pImage->LoadDIBSource(&m_pMask, &m_MatteColor, bStdCS, GroupFamily, bLoadMask);
1547         m_bCached = FALSE;
1548     }
1549     return FALSE;
1550 }
1551 FX_BOOL CPDF_ImageLoader::StartLoadImage(const CPDF_ImageObject* pImage, CPDF_PageRenderCache* pCache, FX_LPVOID& LoadHandle, FX_BOOL bStdCS, FX_DWORD GroupFamily, FX_BOOL bLoadMask, CPDF_RenderStatus* pRenderStatus, FX_INT32 nDownsampleWidth, FX_INT32 nDownsampleHeight)
1552 {
1553     m_nDownsampleWidth = nDownsampleWidth;
1554     m_nDownsampleHeight = nDownsampleHeight;
1555     CPDF_ProgressiveImageLoaderHandle* pLoaderHandle = NULL;
1556     pLoaderHandle =     FX_NEW CPDF_ProgressiveImageLoaderHandle;
1557     FX_BOOL ret = pLoaderHandle->Start(this, pImage, pCache, bStdCS, GroupFamily, bLoadMask, pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
1558     LoadHandle = pLoaderHandle;
1559     return ret;
1560 }
1561 FX_BOOL CPDF_ImageLoader::Continue(FX_LPVOID LoadHandle, IFX_Pause* pPause)
1562 {
1563     return ((CPDF_ProgressiveImageLoaderHandle*)LoadHandle)->Continue(pPause);
1564 }
1565 CPDF_ImageLoader::~CPDF_ImageLoader()
1566 {
1567     if (!m_bCached) {
1568         if (m_pBitmap) {
1569             delete m_pBitmap;
1570             m_pBitmap = NULL;
1571         }
1572         if (m_pMask) {
1573             delete m_pMask;
1574         }
1575     }
1576 }