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