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