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