src/third_party/pdfium/core/src/fpdfapi/fpdf_render/fpdf_render_loadimage.cpp

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