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