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