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