| // Copyright 2014 PDFium Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | |
| #include "core/fpdfapi/fpdf_render/render_int.h" | |
| #include <memory> | |
| #include <utility> | |
| #include <vector> | |
| #include "core/fpdfapi/fpdf_page/cpdf_shadingpattern.h" | |
| #include "core/fpdfapi/fpdf_page/cpdf_tilingpattern.h" | |
| #include "core/fpdfapi/fpdf_page/include/cpdf_form.h" | |
| #include "core/fpdfapi/fpdf_page/include/cpdf_image.h" | |
| #include "core/fpdfapi/fpdf_page/include/cpdf_imageobject.h" | |
| #include "core/fpdfapi/fpdf_page/include/cpdf_page.h" | |
| #include "core/fpdfapi/fpdf_page/pageint.h" | |
| #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h" | |
| #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h" | |
| #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h" | |
| #include "core/fpdfapi/fpdf_render/cpdf_pagerendercache.h" | |
| #include "core/fpdfapi/fpdf_render/include/cpdf_rendercontext.h" | |
| #include "core/fpdfapi/fpdf_render/include/cpdf_renderoptions.h" | |
| #include "core/fpdfdoc/include/cpdf_occontext.h" | |
| #include "core/fxcodec/include/fx_codec.h" | |
| #include "core/fxcrt/include/fx_safe_types.h" | |
| #include "core/fxge/include/cfx_fxgedevice.h" | |
| #include "core/fxge/include/cfx_pathdata.h" | |
| #ifdef _SKIA_SUPPORT_ | |
| #include "core/fxge/skia/fx_skia_device.h" | |
| #endif | |
| FX_BOOL CPDF_RenderStatus::ProcessImage(CPDF_ImageObject* pImageObj, | |
| const CFX_Matrix* pObj2Device) { | |
| CPDF_ImageRenderer render; | |
| if (render.Start(this, pImageObj, pObj2Device, m_bStdCS, m_curBlend)) { | |
| render.Continue(nullptr); | |
| } | |
| return render.m_Result; | |
| } | |
| void CPDF_RenderStatus::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap, | |
| int left, | |
| int top, | |
| FX_ARGB mask_argb, | |
| int bitmap_alpha, | |
| int blend_mode, | |
| int Transparency) { | |
| if (!pDIBitmap) { | |
| return; | |
| } | |
| if (blend_mode == FXDIB_BLEND_NORMAL) { | |
| if (!pDIBitmap->IsAlphaMask()) { | |
| if (bitmap_alpha < 255) { | |
| #ifdef _SKIA_SUPPORT_ | |
| void* dummy; | |
| CFX_Matrix m(pDIBitmap->GetWidth(), 0, 0, -pDIBitmap->GetHeight(), left, | |
| top + pDIBitmap->GetHeight()); | |
| m_pDevice->StartDIBits(pDIBitmap, bitmap_alpha, 0, &m, 0, dummy); | |
| return; | |
| #else | |
| pDIBitmap->MultiplyAlpha(bitmap_alpha); | |
| #endif | |
| } | |
| #ifdef _SKIA_SUPPORT_ | |
| CFX_SkiaDeviceDriver::PreMultiply(pDIBitmap); | |
| #endif | |
| if (m_pDevice->SetDIBits(pDIBitmap, left, top)) { | |
| return; | |
| } | |
| } else { | |
| uint32_t fill_argb = m_Options.TranslateColor(mask_argb); | |
| if (bitmap_alpha < 255) { | |
| ((uint8_t*)&fill_argb)[3] = | |
| ((uint8_t*)&fill_argb)[3] * bitmap_alpha / 255; | |
| } | |
| if (m_pDevice->SetBitMask(pDIBitmap, left, top, fill_argb)) { | |
| return; | |
| } | |
| } | |
| } | |
| bool bIsolated = !!(Transparency & PDFTRANS_ISOLATED); | |
| bool bGroup = !!(Transparency & PDFTRANS_GROUP); | |
| bool bBackAlphaRequired = blend_mode && bIsolated && !m_bDropObjects; | |
| bool bGetBackGround = | |
| ((m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT)) || | |
| (!(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT) && | |
| (m_pDevice->GetRenderCaps() & FXRC_GET_BITS) && !bBackAlphaRequired); | |
| if (bGetBackGround) { | |
| if (bIsolated || !bGroup) { | |
| if (pDIBitmap->IsAlphaMask()) { | |
| return; | |
| } | |
| m_pDevice->SetDIBitsWithBlend(pDIBitmap, left, top, blend_mode); | |
| } else { | |
| FX_RECT rect(left, top, left + pDIBitmap->GetWidth(), | |
| top + pDIBitmap->GetHeight()); | |
| rect.Intersect(m_pDevice->GetClipBox()); | |
| CFX_DIBitmap* pClone = nullptr; | |
| FX_BOOL bClone = FALSE; | |
| if (m_pDevice->GetBackDrop() && m_pDevice->GetBitmap()) { | |
| bClone = TRUE; | |
| pClone = m_pDevice->GetBackDrop()->Clone(&rect); | |
| CFX_DIBitmap* pForeBitmap = m_pDevice->GetBitmap(); | |
| pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(), | |
| pForeBitmap, rect.left, rect.top); | |
| left = left >= 0 ? 0 : left; | |
| top = top >= 0 ? 0 : top; | |
| if (!pDIBitmap->IsAlphaMask()) | |
| pClone->CompositeBitmap(0, 0, pClone->GetWidth(), pClone->GetHeight(), | |
| pDIBitmap, left, top, blend_mode); | |
| else | |
| pClone->CompositeMask(0, 0, pClone->GetWidth(), pClone->GetHeight(), | |
| pDIBitmap, mask_argb, left, top, blend_mode); | |
| } else { | |
| pClone = pDIBitmap; | |
| } | |
| if (m_pDevice->GetBackDrop()) { | |
| m_pDevice->SetDIBits(pClone, rect.left, rect.top); | |
| } else { | |
| if (pDIBitmap->IsAlphaMask()) { | |
| return; | |
| } | |
| m_pDevice->SetDIBitsWithBlend(pDIBitmap, rect.left, rect.top, | |
| blend_mode); | |
| } | |
| if (bClone) { | |
| delete pClone; | |
| } | |
| } | |
| return; | |
| } | |
| int back_left, back_top; | |
| FX_RECT rect(left, top, left + pDIBitmap->GetWidth(), | |
| top + pDIBitmap->GetHeight()); | |
| std::unique_ptr<CFX_DIBitmap> pBackdrop( | |
| GetBackdrop(m_pCurObj, rect, back_left, back_top, | |
| blend_mode > FXDIB_BLEND_NORMAL && bIsolated)); | |
| if (!pBackdrop) | |
| return; | |
| if (!pDIBitmap->IsAlphaMask()) { | |
| pBackdrop->CompositeBitmap(left - back_left, top - back_top, | |
| pDIBitmap->GetWidth(), pDIBitmap->GetHeight(), | |
| pDIBitmap, 0, 0, blend_mode); | |
| } else { | |
| pBackdrop->CompositeMask(left - back_left, top - back_top, | |
| pDIBitmap->GetWidth(), pDIBitmap->GetHeight(), | |
| pDIBitmap, mask_argb, 0, 0, blend_mode); | |
| } | |
| std::unique_ptr<CFX_DIBitmap> pBackdrop1(new CFX_DIBitmap); | |
| pBackdrop1->Create(pBackdrop->GetWidth(), pBackdrop->GetHeight(), | |
| FXDIB_Rgb32); | |
| pBackdrop1->Clear((uint32_t)-1); | |
| pBackdrop1->CompositeBitmap(0, 0, pBackdrop->GetWidth(), | |
| pBackdrop->GetHeight(), pBackdrop.get(), 0, 0); | |
| pBackdrop = std::move(pBackdrop1); | |
| m_pDevice->SetDIBits(pBackdrop.get(), back_left, back_top); | |
| } | |
| CPDF_TransferFunc::CPDF_TransferFunc(CPDF_Document* pDoc) : m_pPDFDoc(pDoc) {} | |
| FX_COLORREF CPDF_TransferFunc::TranslateColor(FX_COLORREF rgb) const { | |
| return FXSYS_RGB(m_Samples[FXSYS_GetRValue(rgb)], | |
| m_Samples[256 + FXSYS_GetGValue(rgb)], | |
| m_Samples[512 + FXSYS_GetBValue(rgb)]); | |
| } | |
| CFX_DIBSource* CPDF_TransferFunc::TranslateImage(const CFX_DIBSource* pSrc, | |
| FX_BOOL bAutoDropSrc) { | |
| CPDF_DIBTransferFunc* pDest = new CPDF_DIBTransferFunc(this); | |
| pDest->LoadSrc(pSrc, bAutoDropSrc); | |
| return pDest; | |
| } | |
| CPDF_DIBTransferFunc::~CPDF_DIBTransferFunc() {} | |
| FXDIB_Format CPDF_DIBTransferFunc::GetDestFormat() { | |
| if (m_pSrc->IsAlphaMask()) { | |
| return FXDIB_8bppMask; | |
| } | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| return (m_pSrc->HasAlpha()) ? FXDIB_Argb : FXDIB_Rgb32; | |
| #else | |
| return (m_pSrc->HasAlpha()) ? FXDIB_Argb : FXDIB_Rgb; | |
| #endif | |
| } | |
| FX_ARGB* CPDF_DIBTransferFunc::GetDestPalette() { | |
| return nullptr; | |
| } | |
| CPDF_DIBTransferFunc::CPDF_DIBTransferFunc( | |
| const CPDF_TransferFunc* pTransferFunc) { | |
| m_RampR = pTransferFunc->m_Samples; | |
| m_RampG = &pTransferFunc->m_Samples[256]; | |
| m_RampB = &pTransferFunc->m_Samples[512]; | |
| } | |
| void CPDF_DIBTransferFunc::TranslateScanline( | |
| const uint8_t* src_buf, | |
| std::vector<uint8_t>* dest_buf) const { | |
| FX_BOOL bSkip = FALSE; | |
| switch (m_pSrc->GetFormat()) { | |
| case FXDIB_1bppRgb: { | |
| int r0 = m_RampR[0]; | |
| int g0 = m_RampG[0]; | |
| int b0 = m_RampB[0]; | |
| int r1 = m_RampR[255]; | |
| int g1 = m_RampG[255]; | |
| int b1 = m_RampB[255]; | |
| int index = 0; | |
| for (int i = 0; i < m_Width; i++) { | |
| if (src_buf[i / 8] & (1 << (7 - i % 8))) { | |
| (*dest_buf)[index++] = b1; | |
| (*dest_buf)[index++] = g1; | |
| (*dest_buf)[index++] = r1; | |
| } else { | |
| (*dest_buf)[index++] = b0; | |
| (*dest_buf)[index++] = g0; | |
| (*dest_buf)[index++] = r0; | |
| } | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| index++; | |
| #endif | |
| } | |
| break; | |
| } | |
| case FXDIB_1bppMask: { | |
| int m0 = m_RampR[0]; | |
| int m1 = m_RampR[255]; | |
| int index = 0; | |
| for (int i = 0; i < m_Width; i++) { | |
| if (src_buf[i / 8] & (1 << (7 - i % 8))) | |
| (*dest_buf)[index++] = m1; | |
| else | |
| (*dest_buf)[index++] = m0; | |
| } | |
| break; | |
| } | |
| case FXDIB_8bppRgb: { | |
| FX_ARGB* pPal = m_pSrc->GetPalette(); | |
| int index = 0; | |
| for (int i = 0; i < m_Width; i++) { | |
| if (pPal) { | |
| FX_ARGB src_argb = pPal[*src_buf]; | |
| (*dest_buf)[index++] = m_RampB[FXARGB_R(src_argb)]; | |
| (*dest_buf)[index++] = m_RampG[FXARGB_G(src_argb)]; | |
| (*dest_buf)[index++] = m_RampR[FXARGB_B(src_argb)]; | |
| } else { | |
| uint32_t src_byte = *src_buf; | |
| (*dest_buf)[index++] = m_RampB[src_byte]; | |
| (*dest_buf)[index++] = m_RampG[src_byte]; | |
| (*dest_buf)[index++] = m_RampR[src_byte]; | |
| } | |
| src_buf++; | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| index++; | |
| #endif | |
| } | |
| break; | |
| } | |
| case FXDIB_8bppMask: { | |
| int index = 0; | |
| for (int i = 0; i < m_Width; i++) { | |
| (*dest_buf)[index++] = m_RampR[*(src_buf++)]; | |
| } | |
| break; | |
| } | |
| case FXDIB_Rgb: { | |
| int index = 0; | |
| for (int i = 0; i < m_Width; i++) { | |
| (*dest_buf)[index++] = m_RampB[*(src_buf++)]; | |
| (*dest_buf)[index++] = m_RampG[*(src_buf++)]; | |
| (*dest_buf)[index++] = m_RampR[*(src_buf++)]; | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| index++; | |
| #endif | |
| } | |
| break; | |
| } | |
| case FXDIB_Rgb32: | |
| bSkip = TRUE; | |
| case FXDIB_Argb: { | |
| int index = 0; | |
| for (int i = 0; i < m_Width; i++) { | |
| (*dest_buf)[index++] = m_RampB[*(src_buf++)]; | |
| (*dest_buf)[index++] = m_RampG[*(src_buf++)]; | |
| (*dest_buf)[index++] = m_RampR[*(src_buf++)]; | |
| if (!bSkip) { | |
| (*dest_buf)[index++] = *src_buf; | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| } else { | |
| index++; | |
| #endif | |
| } | |
| src_buf++; | |
| } | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| void CPDF_DIBTransferFunc::TranslateDownSamples(uint8_t* dest_buf, | |
| const uint8_t* src_buf, | |
| int pixels, | |
| int Bpp) const { | |
| if (Bpp == 8) { | |
| for (int i = 0; i < pixels; i++) { | |
| *dest_buf++ = m_RampR[*(src_buf++)]; | |
| } | |
| } else if (Bpp == 24) { | |
| for (int i = 0; i < pixels; i++) { | |
| *dest_buf++ = m_RampB[*(src_buf++)]; | |
| *dest_buf++ = m_RampG[*(src_buf++)]; | |
| *dest_buf++ = m_RampR[*(src_buf++)]; | |
| } | |
| } else { | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| if (!m_pSrc->HasAlpha()) { | |
| for (int i = 0; i < pixels; i++) { | |
| *dest_buf++ = m_RampB[*(src_buf++)]; | |
| *dest_buf++ = m_RampG[*(src_buf++)]; | |
| *dest_buf++ = m_RampR[*(src_buf++)]; | |
| dest_buf++; | |
| src_buf++; | |
| } | |
| } else { | |
| #endif | |
| for (int i = 0; i < pixels; i++) { | |
| *dest_buf++ = m_RampB[*(src_buf++)]; | |
| *dest_buf++ = m_RampG[*(src_buf++)]; | |
| *dest_buf++ = m_RampR[*(src_buf++)]; | |
| *dest_buf++ = *(src_buf++); | |
| } | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ | |
| } | |
| #endif | |
| } | |
| } | |
| CPDF_ImageRenderer::CPDF_ImageRenderer() { | |
| m_pRenderStatus = nullptr; | |
| m_pImageObject = nullptr; | |
| m_Result = TRUE; | |
| m_Status = 0; | |
| m_DeviceHandle = nullptr; | |
| m_bStdCS = FALSE; | |
| m_bPatternColor = FALSE; | |
| m_BlendType = FXDIB_BLEND_NORMAL; | |
| m_pPattern = nullptr; | |
| m_pObj2Device = nullptr; | |
| } | |
| CPDF_ImageRenderer::~CPDF_ImageRenderer() { | |
| if (m_DeviceHandle) { | |
| m_pRenderStatus->m_pDevice->CancelDIBits(m_DeviceHandle); | |
| } | |
| } | |
| FX_BOOL CPDF_ImageRenderer::StartLoadDIBSource() { | |
| CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect(); | |
| FX_RECT image_rect = image_rect_f.GetOuterRect(); | |
| if (!image_rect.Valid()) | |
| return FALSE; | |
| int dest_width = image_rect.Width(); | |
| int dest_height = image_rect.Height(); | |
| if (m_ImageMatrix.a < 0) { | |
| dest_width = -dest_width; | |
| } | |
| if (m_ImageMatrix.d > 0) { | |
| dest_height = -dest_height; | |
| } | |
| if (m_Loader.Start(m_pImageObject, | |
| m_pRenderStatus->m_pContext->GetPageCache(), &m_LoadHandle, | |
| m_bStdCS, m_pRenderStatus->m_GroupFamily, | |
| m_pRenderStatus->m_bLoadMask, m_pRenderStatus, dest_width, | |
| dest_height)) { | |
| if (m_LoadHandle) { | |
| m_Status = 4; | |
| return TRUE; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| FX_BOOL CPDF_ImageRenderer::StartRenderDIBSource() { | |
| if (!m_Loader.m_pBitmap) | |
| return FALSE; | |
| m_BitmapAlpha = | |
| FXSYS_round(255 * m_pImageObject->m_GeneralState.GetFillAlpha()); | |
| m_pDIBSource = m_Loader.m_pBitmap; | |
| if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_ALPHA && | |
| !m_Loader.m_pMask) { | |
| return StartBitmapAlpha(); | |
| } | |
| if (m_pImageObject->m_GeneralState.GetTR()) { | |
| if (!m_pImageObject->m_GeneralState.GetTransferFunc()) { | |
| m_pImageObject->m_GeneralState.SetTransferFunc( | |
| m_pRenderStatus->GetTransferFunc( | |
| m_pImageObject->m_GeneralState.GetTR())); | |
| } | |
| if (m_pImageObject->m_GeneralState.GetTransferFunc() && | |
| !m_pImageObject->m_GeneralState.GetTransferFunc()->m_bIdentity) { | |
| m_pDIBSource = m_Loader.m_pBitmap = | |
| m_pImageObject->m_GeneralState.GetTransferFunc()->TranslateImage( | |
| m_Loader.m_pBitmap, !m_Loader.m_bCached); | |
| if (m_Loader.m_bCached && m_Loader.m_pMask) { | |
| m_Loader.m_pMask = m_Loader.m_pMask->Clone(); | |
| } | |
| m_Loader.m_bCached = FALSE; | |
| } | |
| } | |
| m_FillArgb = 0; | |
| m_bPatternColor = FALSE; | |
| m_pPattern = nullptr; | |
| if (m_pDIBSource->IsAlphaMask()) { | |
| const CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor(); | |
| if (pColor && pColor->IsPattern()) { | |
| m_pPattern = pColor->GetPattern(); | |
| if (m_pPattern) { | |
| m_bPatternColor = TRUE; | |
| } | |
| } | |
| m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject); | |
| } else if (m_pRenderStatus->m_Options.m_ColorMode == RENDER_COLOR_GRAY) { | |
| m_pClone.reset(m_pDIBSource->Clone()); | |
| m_pClone->ConvertColorScale(m_pRenderStatus->m_Options.m_BackColor, | |
| m_pRenderStatus->m_Options.m_ForeColor); | |
| m_pDIBSource = m_pClone.get(); | |
| } | |
| m_Flags = 0; | |
| if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_DOWNSAMPLE) { | |
| m_Flags |= RENDER_FORCE_DOWNSAMPLE; | |
| } else if (m_pRenderStatus->m_Options.m_Flags & RENDER_FORCE_HALFTONE) { | |
| m_Flags |= RENDER_FORCE_HALFTONE; | |
| } | |
| if (m_pRenderStatus->m_pDevice->GetDeviceClass() != FXDC_DISPLAY) { | |
| CPDF_Object* pFilters = | |
| m_pImageObject->GetImage()->GetStream()->GetDict()->GetDirectObjectBy( | |
| "Filter"); | |
| if (pFilters) { | |
| if (pFilters->IsName()) { | |
| CFX_ByteString bsDecodeType = pFilters->GetString(); | |
| if (bsDecodeType == "DCTDecode" || bsDecodeType == "JPXDecode") { | |
| m_Flags |= FXRENDER_IMAGE_LOSSY; | |
| } | |
| } else if (CPDF_Array* pArray = pFilters->AsArray()) { | |
| for (size_t i = 0; i < pArray->GetCount(); i++) { | |
| CFX_ByteString bsDecodeType = pArray->GetStringAt(i); | |
| if (bsDecodeType == "DCTDecode" || bsDecodeType == "JPXDecode") { | |
| m_Flags |= FXRENDER_IMAGE_LOSSY; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (m_pRenderStatus->m_Options.m_Flags & RENDER_NOIMAGESMOOTH) { | |
| m_Flags |= FXDIB_NOSMOOTH; | |
| } else if (m_pImageObject->GetImage()->IsInterpol()) { | |
| m_Flags |= FXDIB_INTERPOL; | |
| } | |
| if (m_Loader.m_pMask) { | |
| return DrawMaskedImage(); | |
| } | |
| if (m_bPatternColor) { | |
| return DrawPatternImage(m_pObj2Device); | |
| } | |
| if (m_BitmapAlpha == 255 && m_pImageObject->m_GeneralState && | |
| m_pImageObject->m_GeneralState.GetFillOP() && | |
| m_pImageObject->m_GeneralState.GetOPMode() == 0 && | |
| m_pImageObject->m_GeneralState.GetBlendType() == FXDIB_BLEND_NORMAL && | |
| m_pImageObject->m_GeneralState.GetStrokeAlpha() == 1.0f && | |
| m_pImageObject->m_GeneralState.GetFillAlpha() == 1.0f) { | |
| CPDF_Document* pDocument = nullptr; | |
| CPDF_Page* pPage = nullptr; | |
| if (m_pRenderStatus->m_pContext->GetPageCache()) { | |
| pPage = m_pRenderStatus->m_pContext->GetPageCache()->GetPage(); | |
| pDocument = pPage->m_pDocument; | |
| } else { | |
| pDocument = m_pImageObject->GetImage()->GetDocument(); | |
| } | |
| CPDF_Dictionary* pPageResources = pPage ? pPage->m_pPageResources : nullptr; | |
| CPDF_Object* pCSObj = | |
| m_pImageObject->GetImage()->GetStream()->GetDict()->GetDirectObjectBy( | |
| "ColorSpace"); | |
| CPDF_ColorSpace* pColorSpace = | |
| pDocument->LoadColorSpace(pCSObj, pPageResources); | |
| if (pColorSpace) { | |
| int format = pColorSpace->GetFamily(); | |
| if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION || | |
| format == PDFCS_DEVICEN) { | |
| m_BlendType = FXDIB_BLEND_DARKEN; | |
| } | |
| pDocument->GetPageData()->ReleaseColorSpace(pCSObj); | |
| } | |
| } | |
| return StartDIBSource(); | |
| } | |
| FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, | |
| CPDF_PageObject* pObj, | |
| const CFX_Matrix* pObj2Device, | |
| FX_BOOL bStdCS, | |
| int blendType) { | |
| m_pRenderStatus = pStatus; | |
| m_bStdCS = bStdCS; | |
| m_pImageObject = pObj->AsImage(); | |
| m_BlendType = blendType; | |
| m_pObj2Device = pObj2Device; | |
| CPDF_Dictionary* pOC = m_pImageObject->GetImage()->GetOC(); | |
| if (pOC && m_pRenderStatus->m_Options.m_pOCContext && | |
| !m_pRenderStatus->m_Options.m_pOCContext->CheckOCGVisible(pOC)) { | |
| return FALSE; | |
| } | |
| m_ImageMatrix = m_pImageObject->m_Matrix; | |
| m_ImageMatrix.Concat(*pObj2Device); | |
| if (StartLoadDIBSource()) { | |
| return TRUE; | |
| } | |
| return StartRenderDIBSource(); | |
| } | |
| FX_BOOL CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus, | |
| const CFX_DIBSource* pDIBSource, | |
| FX_ARGB bitmap_argb, | |
| int bitmap_alpha, | |
| const CFX_Matrix* pImage2Device, | |
| uint32_t flags, | |
| FX_BOOL bStdCS, | |
| int blendType) { | |
| m_pRenderStatus = pStatus; | |
| m_pDIBSource = pDIBSource; | |
| m_FillArgb = bitmap_argb; | |
| m_BitmapAlpha = bitmap_alpha; | |
| m_ImageMatrix = *pImage2Device; | |
| m_Flags = flags; | |
| m_bStdCS = bStdCS; | |
| m_BlendType = blendType; | |
| return StartDIBSource(); | |
| } | |
| FX_BOOL CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) { | |
| if (m_pRenderStatus->m_bPrint && | |
| !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) { | |
| m_Result = FALSE; | |
| return FALSE; | |
| } | |
| FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect(); | |
| rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox()); | |
| if (rect.IsEmpty()) { | |
| return FALSE; | |
| } | |
| CFX_Matrix new_matrix = m_ImageMatrix; | |
| new_matrix.TranslateI(-rect.left, -rect.top); | |
| int width = rect.Width(); | |
| int height = rect.Height(); | |
| CFX_FxgeDevice bitmap_device1; | |
| if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Rgb32, nullptr)) | |
| return TRUE; | |
| bitmap_device1.GetBitmap()->Clear(0xffffff); | |
| { | |
| CPDF_RenderStatus bitmap_render; | |
| bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, | |
| nullptr, nullptr, nullptr, nullptr, | |
| &m_pRenderStatus->m_Options, 0, | |
| m_pRenderStatus->m_bDropObjects, nullptr, TRUE); | |
| CFX_Matrix patternDevice = *pObj2Device; | |
| patternDevice.Translate((FX_FLOAT)-rect.left, (FX_FLOAT)-rect.top); | |
| if (CPDF_TilingPattern* pTilingPattern = m_pPattern->AsTilingPattern()) { | |
| bitmap_render.DrawTilingPattern(pTilingPattern, m_pImageObject, | |
| &patternDevice, FALSE); | |
| } else if (CPDF_ShadingPattern* pShadingPattern = | |
| m_pPattern->AsShadingPattern()) { | |
| bitmap_render.DrawShadingPattern(pShadingPattern, m_pImageObject, | |
| &patternDevice, FALSE); | |
| } | |
| } | |
| { | |
| CFX_FxgeDevice bitmap_device2; | |
| if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb, | |
| nullptr)) { | |
| return TRUE; | |
| } | |
| bitmap_device2.GetBitmap()->Clear(0); | |
| CPDF_RenderStatus bitmap_render; | |
| bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, | |
| nullptr, nullptr, nullptr, nullptr, nullptr, 0, | |
| m_pRenderStatus->m_bDropObjects, nullptr, TRUE); | |
| CPDF_ImageRenderer image_render; | |
| if (image_render.Start(&bitmap_render, m_pDIBSource, 0xffffffff, 255, | |
| &new_matrix, m_Flags, TRUE)) { | |
| image_render.Continue(nullptr); | |
| } | |
| if (m_Loader.m_MatteColor != 0xffffffff) { | |
| int matte_r = FXARGB_R(m_Loader.m_MatteColor); | |
| int matte_g = FXARGB_G(m_Loader.m_MatteColor); | |
| int matte_b = FXARGB_B(m_Loader.m_MatteColor); | |
| for (int row = 0; row < height; row++) { | |
| uint8_t* dest_scan = | |
| (uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row); | |
| const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row); | |
| for (int col = 0; col < width; col++) { | |
| int alpha = *mask_scan++; | |
| if (alpha) { | |
| int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b; | |
| if (orig < 0) { | |
| orig = 0; | |
| } else if (orig > 255) { | |
| orig = 255; | |
| } | |
| *dest_scan++ = orig; | |
| orig = (*dest_scan - matte_g) * 255 / alpha + matte_g; | |
| if (orig < 0) { | |
| orig = 0; | |
| } else if (orig > 255) { | |
| orig = 255; | |
| } | |
| *dest_scan++ = orig; | |
| orig = (*dest_scan - matte_r) * 255 / alpha + matte_r; | |
| if (orig < 0) { | |
| orig = 0; | |
| } else if (orig > 255) { | |
| orig = 255; | |
| } | |
| *dest_scan++ = orig; | |
| dest_scan++; | |
| } else { | |
| dest_scan += 4; | |
| } | |
| } | |
| } | |
| } | |
| bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask); | |
| bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap()); | |
| bitmap_device1.GetBitmap()->MultiplyAlpha(255); | |
| } | |
| m_pRenderStatus->m_pDevice->SetDIBitsWithBlend( | |
| bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType); | |
| return FALSE; | |
| } | |
| FX_BOOL CPDF_ImageRenderer::DrawMaskedImage() { | |
| if (m_pRenderStatus->m_bPrint && | |
| !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) { | |
| m_Result = FALSE; | |
| return FALSE; | |
| } | |
| FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect(); | |
| rect.Intersect(m_pRenderStatus->m_pDevice->GetClipBox()); | |
| if (rect.IsEmpty()) { | |
| return FALSE; | |
| } | |
| CFX_Matrix new_matrix = m_ImageMatrix; | |
| new_matrix.TranslateI(-rect.left, -rect.top); | |
| int width = rect.Width(); | |
| int height = rect.Height(); | |
| CFX_FxgeDevice bitmap_device1; | |
| if (!bitmap_device1.Create(width, height, FXDIB_Rgb32, nullptr)) | |
| return TRUE; | |
| #if defined _SKIA_SUPPORT_ | |
| bitmap_device1.Clear(0xffffff); | |
| #else | |
| bitmap_device1.GetBitmap()->Clear(0xffffff); | |
| #endif | |
| { | |
| CPDF_RenderStatus bitmap_render; | |
| bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device1, | |
| nullptr, nullptr, nullptr, nullptr, nullptr, 0, | |
| m_pRenderStatus->m_bDropObjects, nullptr, TRUE); | |
| CPDF_ImageRenderer image_render; | |
| if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix, | |
| m_Flags, TRUE)) { | |
| image_render.Continue(nullptr); | |
| } | |
| } | |
| { | |
| CFX_FxgeDevice bitmap_device2; | |
| if (!bitmap_device2.Create(width, height, FXDIB_8bppRgb, nullptr)) | |
| return TRUE; | |
| #if defined _SKIA_SUPPORT_ | |
| bitmap_device2.Clear(0); | |
| #else | |
| bitmap_device2.GetBitmap()->Clear(0); | |
| #endif | |
| CPDF_RenderStatus bitmap_render; | |
| bitmap_render.Initialize(m_pRenderStatus->m_pContext, &bitmap_device2, | |
| nullptr, nullptr, nullptr, nullptr, nullptr, 0, | |
| m_pRenderStatus->m_bDropObjects, nullptr, TRUE); | |
| CPDF_ImageRenderer image_render; | |
| if (image_render.Start(&bitmap_render, m_Loader.m_pMask, 0xffffffff, 255, | |
| &new_matrix, m_Flags, TRUE)) { | |
| image_render.Continue(nullptr); | |
| } | |
| if (m_Loader.m_MatteColor != 0xffffffff) { | |
| int matte_r = FXARGB_R(m_Loader.m_MatteColor); | |
| int matte_g = FXARGB_G(m_Loader.m_MatteColor); | |
| int matte_b = FXARGB_B(m_Loader.m_MatteColor); | |
| for (int row = 0; row < height; row++) { | |
| uint8_t* dest_scan = | |
| (uint8_t*)bitmap_device1.GetBitmap()->GetScanline(row); | |
| const uint8_t* mask_scan = bitmap_device2.GetBitmap()->GetScanline(row); | |
| for (int col = 0; col < width; col++) { | |
| int alpha = *mask_scan++; | |
| if (alpha) { | |
| int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b; | |
| if (orig < 0) { | |
| orig = 0; | |
| } else if (orig > 255) { | |
| orig = 255; | |
| } | |
| *dest_scan++ = orig; | |
| orig = (*dest_scan - matte_g) * 255 / alpha + matte_g; | |
| if (orig < 0) { | |
| orig = 0; | |
| } else if (orig > 255) { | |
| orig = 255; | |
| } | |
| *dest_scan++ = orig; | |
| orig = (*dest_scan - matte_r) * 255 / alpha + matte_r; | |
| if (orig < 0) { | |
| orig = 0; | |
| } else if (orig > 255) { | |
| orig = 255; | |
| } | |
| *dest_scan++ = orig; | |
| dest_scan++; | |
| } else { | |
| dest_scan += 4; | |
| } | |
| } | |
| } | |
| } | |
| #ifdef _SKIA_SUPPORT_ | |
| m_pRenderStatus->m_pDevice->SetBitsWithMask( | |
| bitmap_device1.GetBitmap(), bitmap_device2.GetBitmap(), rect.left, | |
| rect.top, m_BitmapAlpha, m_BlendType); | |
| } | |
| #else | |
| bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask); | |
| bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap()); | |
| if (m_BitmapAlpha < 255) { | |
| bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha); | |
| } | |
| } | |
| m_pRenderStatus->m_pDevice->SetDIBitsWithBlend( | |
| bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType); | |
| #endif // _SKIA_SUPPORT_ | |
| return FALSE; | |
| } | |
| FX_BOOL CPDF_ImageRenderer::StartDIBSource() { | |
| if (!(m_Flags & RENDER_FORCE_DOWNSAMPLE) && m_pDIBSource->GetBPP() > 1) { | |
| int image_size = m_pDIBSource->GetBPP() / 8 * m_pDIBSource->GetWidth() * | |
| m_pDIBSource->GetHeight(); | |
| if (image_size > FPDF_HUGE_IMAGE_SIZE && | |
| !(m_Flags & RENDER_FORCE_HALFTONE)) { | |
| m_Flags |= RENDER_FORCE_DOWNSAMPLE; | |
| } | |
| } | |
| #ifdef _SKIA_SUPPORT_ | |
| CFX_DIBitmap* premultiplied = m_pDIBSource->Clone(); | |
| if (m_pDIBSource->HasAlpha()) | |
| CFX_SkiaDeviceDriver::PreMultiply(premultiplied); | |
| if (m_pRenderStatus->m_pDevice->StartDIBitsWithBlend( | |
| premultiplied, m_BitmapAlpha, m_FillArgb, &m_ImageMatrix, m_Flags, | |
| m_DeviceHandle, m_BlendType)) { | |
| if (m_DeviceHandle) { | |
| m_Status = 3; | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| #else | |
| if (m_pRenderStatus->m_pDevice->StartDIBitsWithBlend( | |
| m_pDIBSource, m_BitmapAlpha, m_FillArgb, &m_ImageMatrix, m_Flags, | |
| m_DeviceHandle, m_BlendType)) { | |
| if (m_DeviceHandle) { | |
| m_Status = 3; | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| #endif | |
| CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect(); | |
| FX_RECT image_rect = image_rect_f.GetOuterRect(); | |
| int dest_width = image_rect.Width(); | |
| int dest_height = image_rect.Height(); | |
| if ((FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) || | |
| (FXSYS_fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0)) { | |
| if (m_pRenderStatus->m_bPrint && | |
| !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) { | |
| m_Result = FALSE; | |
| return FALSE; | |
| } | |
| FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox(); | |
| clip_box.Intersect(image_rect); | |
| m_Status = 2; | |
| m_pTransformer.reset(new CFX_ImageTransformer(m_pDIBSource, &m_ImageMatrix, | |
| m_Flags, &clip_box)); | |
| m_pTransformer->Start(); | |
| return TRUE; | |
| } | |
| if (m_ImageMatrix.a < 0) | |
| dest_width = -dest_width; | |
| if (m_ImageMatrix.d > 0) | |
| dest_height = -dest_height; | |
| int dest_left = dest_width > 0 ? image_rect.left : image_rect.right; | |
| int dest_top = dest_height > 0 ? image_rect.top : image_rect.bottom; | |
| if (m_pDIBSource->IsOpaqueImage() && m_BitmapAlpha == 255) { | |
| if (m_pRenderStatus->m_pDevice->StretchDIBitsWithFlagsAndBlend( | |
| m_pDIBSource, dest_left, dest_top, dest_width, dest_height, m_Flags, | |
| m_BlendType)) { | |
| return FALSE; | |
| } | |
| } | |
| if (m_pDIBSource->IsAlphaMask()) { | |
| if (m_BitmapAlpha != 255) | |
| m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha); | |
| if (m_pRenderStatus->m_pDevice->StretchBitMaskWithFlags( | |
| m_pDIBSource, dest_left, dest_top, dest_width, dest_height, | |
| m_FillArgb, m_Flags)) { | |
| return FALSE; | |
| } | |
| } | |
| if (m_pRenderStatus->m_bPrint && | |
| !(m_pRenderStatus->m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) { | |
| m_Result = FALSE; | |
| return TRUE; | |
| } | |
| FX_RECT clip_box = m_pRenderStatus->m_pDevice->GetClipBox(); | |
| FX_RECT dest_rect = clip_box; | |
| dest_rect.Intersect(image_rect); | |
| FX_RECT dest_clip( | |
| dest_rect.left - image_rect.left, dest_rect.top - image_rect.top, | |
| dest_rect.right - image_rect.left, dest_rect.bottom - image_rect.top); | |
| std::unique_ptr<CFX_DIBitmap> pStretched( | |
| m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip)); | |
| if (pStretched) { | |
| m_pRenderStatus->CompositeDIBitmap(pStretched.get(), dest_rect.left, | |
| dest_rect.top, m_FillArgb, m_BitmapAlpha, | |
| m_BlendType, FALSE); | |
| } | |
| return FALSE; | |
| } | |
| FX_BOOL CPDF_ImageRenderer::StartBitmapAlpha() { | |
| if (m_pDIBSource->IsOpaqueImage()) { | |
| CFX_PathData path; | |
| path.AppendRect(0, 0, 1, 1); | |
| path.Transform(&m_ImageMatrix); | |
| uint32_t fill_color = | |
| ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha); | |
| m_pRenderStatus->m_pDevice->DrawPath(&path, nullptr, nullptr, fill_color, 0, | |
| FXFILL_WINDING); | |
| } else { | |
| const CFX_DIBSource* pAlphaMask = m_pDIBSource->IsAlphaMask() | |
| ? m_pDIBSource | |
| : m_pDIBSource->GetAlphaMask(); | |
| if (FXSYS_fabs(m_ImageMatrix.b) >= 0.5f || | |
| FXSYS_fabs(m_ImageMatrix.c) >= 0.5f) { | |
| int left, top; | |
| std::unique_ptr<CFX_DIBitmap> pTransformed( | |
| pAlphaMask->TransformTo(&m_ImageMatrix, left, top)); | |
| if (!pTransformed) | |
| return TRUE; | |
| m_pRenderStatus->m_pDevice->SetBitMask( | |
| pTransformed.get(), left, top, | |
| ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha)); | |
| } else { | |
| CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect(); | |
| FX_RECT image_rect = image_rect_f.GetOuterRect(); | |
| int dest_width = | |
| m_ImageMatrix.a > 0 ? image_rect.Width() : -image_rect.Width(); | |
| int dest_height = | |
| m_ImageMatrix.d > 0 ? -image_rect.Height() : image_rect.Height(); | |
| int left = dest_width > 0 ? image_rect.left : image_rect.right; | |
| int top = dest_height > 0 ? image_rect.top : image_rect.bottom; | |
| m_pRenderStatus->m_pDevice->StretchBitMask( | |
| pAlphaMask, left, top, dest_width, dest_height, | |
| ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha)); | |
| } | |
| if (m_pDIBSource != pAlphaMask) { | |
| delete pAlphaMask; | |
| } | |
| } | |
| return FALSE; | |
| } | |
| FX_BOOL CPDF_ImageRenderer::Continue(IFX_Pause* pPause) { | |
| if (m_Status == 2) { | |
| if (m_pTransformer->Continue(pPause)) | |
| return TRUE; | |
| std::unique_ptr<CFX_DIBitmap> pBitmap(m_pTransformer->DetachBitmap()); | |
| if (!pBitmap) | |
| return FALSE; | |
| if (pBitmap->IsAlphaMask()) { | |
| if (m_BitmapAlpha != 255) | |
| m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha); | |
| m_Result = m_pRenderStatus->m_pDevice->SetBitMask( | |
| pBitmap.get(), m_pTransformer->result().left, | |
| m_pTransformer->result().top, m_FillArgb); | |
| } else { | |
| if (m_BitmapAlpha != 255) | |
| pBitmap->MultiplyAlpha(m_BitmapAlpha); | |
| m_Result = m_pRenderStatus->m_pDevice->SetDIBitsWithBlend( | |
| pBitmap.get(), m_pTransformer->result().left, | |
| m_pTransformer->result().top, m_BlendType); | |
| } | |
| return FALSE; | |
| } | |
| if (m_Status == 3) | |
| return m_pRenderStatus->m_pDevice->ContinueDIBits(m_DeviceHandle, pPause); | |
| if (m_Status == 4) { | |
| if (m_Loader.Continue(m_LoadHandle.get(), pPause)) | |
| return TRUE; | |
| if (StartRenderDIBSource()) | |
| return Continue(pPause); | |
| } | |
| return FALSE; | |
| } | |
| CCodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder( | |
| const uint8_t* src_buf, | |
| uint32_t src_size, | |
| int width, | |
| int height, | |
| int nComps, | |
| int bpc, | |
| const CPDF_Dictionary* pParams); | |
| CFX_DIBitmap* CPDF_RenderStatus::LoadSMask(CPDF_Dictionary* pSMaskDict, | |
| FX_RECT* pClipRect, | |
| const CFX_Matrix* pMatrix) { | |
| if (!pSMaskDict) | |
| return nullptr; | |
| CPDF_Stream* pGroup = pSMaskDict->GetStreamBy("G"); | |
| if (!pGroup) | |
| return nullptr; | |
| std::unique_ptr<CPDF_Function> pFunc; | |
| CPDF_Object* pFuncObj = pSMaskDict->GetDirectObjectBy("TR"); | |
| if (pFuncObj && (pFuncObj->IsDictionary() || pFuncObj->IsStream())) | |
| pFunc = CPDF_Function::Load(pFuncObj); | |
| CFX_Matrix matrix = *pMatrix; | |
| matrix.TranslateI(-pClipRect->left, -pClipRect->top); | |
| CPDF_Form form(m_pContext->GetDocument(), m_pContext->GetPageResources(), | |
| pGroup); | |
| form.ParseContent(nullptr, nullptr, nullptr); | |
| CFX_FxgeDevice bitmap_device; | |
| FX_BOOL bLuminosity = pSMaskDict->GetStringBy("S") != "Alpha"; | |
| int width = pClipRect->right - pClipRect->left; | |
| int height = pClipRect->bottom - pClipRect->top; | |
| FXDIB_Format format; | |
| #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || defined _SKIA_SUPPORT_ | |
| format = bLuminosity ? FXDIB_Rgb32 : FXDIB_8bppMask; | |
| #else | |
| format = bLuminosity ? FXDIB_Rgb : FXDIB_8bppMask; | |
| #endif | |
| if (!bitmap_device.Create(width, height, format, nullptr)) | |
| return nullptr; | |
| CFX_DIBitmap& bitmap = *bitmap_device.GetBitmap(); | |
| CPDF_Object* pCSObj = nullptr; | |
| CPDF_ColorSpace* pCS = nullptr; | |
| if (bLuminosity) { | |
| CPDF_Array* pBC = pSMaskDict->GetArrayBy("BC"); | |
| FX_ARGB back_color = 0xff000000; | |
| if (pBC) { | |
| CPDF_Dictionary* pDict = pGroup->GetDict(); | |
| if (pDict && pDict->GetDictBy("Group")) | |
| pCSObj = pDict->GetDictBy("Group")->GetDirectObjectBy("CS"); | |
| else | |
| pCSObj = nullptr; | |
| pCS = m_pContext->GetDocument()->LoadColorSpace(pCSObj); | |
| if (pCS) { | |
| FX_FLOAT R, G, B; | |
| uint32_t comps = 8; | |
| if (pCS->CountComponents() > comps) { | |
| comps = pCS->CountComponents(); | |
| } | |
| CFX_FixedBufGrow<FX_FLOAT, 8> float_array(comps); | |
| FX_FLOAT* pFloats = float_array; | |
| FX_SAFE_UINT32 num_floats = comps; | |
| num_floats *= sizeof(FX_FLOAT); | |
| if (!num_floats.IsValid()) { | |
| return nullptr; | |
| } | |
| FXSYS_memset(pFloats, 0, num_floats.ValueOrDie()); | |
| size_t count = pBC->GetCount() > 8 ? 8 : pBC->GetCount(); | |
| for (size_t i = 0; i < count; i++) { | |
| pFloats[i] = pBC->GetNumberAt(i); | |
| } | |
| pCS->GetRGB(pFloats, R, G, B); | |
| back_color = 0xff000000 | ((int32_t)(R * 255) << 16) | | |
| ((int32_t)(G * 255) << 8) | (int32_t)(B * 255); | |
| m_pContext->GetDocument()->GetPageData()->ReleaseColorSpace(pCSObj); | |
| } | |
| } | |
| bitmap.Clear(back_color); | |
| } else { | |
| bitmap.Clear(0); | |
| } | |
| CPDF_Dictionary* pFormResource = nullptr; | |
| if (form.m_pFormDict) { | |
| pFormResource = form.m_pFormDict->GetDictBy("Resources"); | |
| } | |
| CPDF_RenderOptions options; | |
| options.m_ColorMode = bLuminosity ? RENDER_COLOR_NORMAL : RENDER_COLOR_ALPHA; | |
| CPDF_RenderStatus status; | |
| status.Initialize(m_pContext, &bitmap_device, nullptr, nullptr, nullptr, | |
| nullptr, &options, 0, m_bDropObjects, pFormResource, TRUE, | |
| nullptr, 0, pCS ? pCS->GetFamily() : 0, bLuminosity); | |
| status.RenderObjectList(&form, &matrix); | |
| std::unique_ptr<CFX_DIBitmap> pMask(new CFX_DIBitmap); | |
| if (!pMask->Create(width, height, FXDIB_8bppMask)) | |
| return nullptr; | |
| uint8_t* dest_buf = pMask->GetBuffer(); | |
| int dest_pitch = pMask->GetPitch(); | |
| uint8_t* src_buf = bitmap.GetBuffer(); | |
| int src_pitch = bitmap.GetPitch(); | |
| std::vector<uint8_t> transfers(256); | |
| if (pFunc) { | |
| CFX_FixedBufGrow<FX_FLOAT, 16> results(pFunc->CountOutputs()); | |
| for (int i = 0; i < 256; i++) { | |
| FX_FLOAT input = (FX_FLOAT)i / 255.0f; | |
| int nresult; | |
| pFunc->Call(&input, 1, results, nresult); | |
| transfers[i] = FXSYS_round(results[0] * 255); | |
| } | |
| } else { | |
| for (int i = 0; i < 256; i++) { | |
| transfers[i] = i; | |
| } | |
| } | |
| if (bLuminosity) { | |
| int Bpp = bitmap.GetBPP() / 8; | |
| for (int row = 0; row < height; row++) { | |
| uint8_t* dest_pos = dest_buf + row * dest_pitch; | |
| uint8_t* src_pos = src_buf + row * src_pitch; | |
| for (int col = 0; col < width; col++) { | |
| *dest_pos++ = transfers[FXRGB2GRAY(src_pos[2], src_pos[1], *src_pos)]; | |
| src_pos += Bpp; | |
| } | |
| } | |
| } else if (pFunc) { | |
| int size = dest_pitch * height; | |
| for (int i = 0; i < size; i++) { | |
| dest_buf[i] = transfers[src_buf[i]]; | |
| } | |
| } else { | |
| FXSYS_memcpy(dest_buf, src_buf, dest_pitch * height); | |
| } | |
| return pMask.release(); | |
| } |