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