Index: core/fpdfapi/fpdf_render/fpdf_render_image.cpp |
diff --git a/core/fpdfapi/fpdf_render/fpdf_render_image.cpp b/core/fpdfapi/fpdf_render/fpdf_render_image.cpp |
deleted file mode 100644 |
index d5a28a60193a96f0f1e84593d55991e40622b708..0000000000000000000000000000000000000000 |
--- a/core/fpdfapi/fpdf_render/fpdf_render_image.cpp |
+++ /dev/null |
@@ -1,1088 +0,0 @@ |
-// 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_render/cpdf_pagerendercache.h" |
-#include "core/fpdfapi/fpdf_render/cpdf_rendercontext.h" |
-#include "core/fpdfapi/fpdf_render/cpdf_renderoptions.h" |
-#include "core/fpdfapi/page/cpdf_form.h" |
-#include "core/fpdfapi/page/cpdf_image.h" |
-#include "core/fpdfapi/page/cpdf_imageobject.h" |
-#include "core/fpdfapi/page/cpdf_page.h" |
-#include "core/fpdfapi/page/cpdf_shadingpattern.h" |
-#include "core/fpdfapi/page/cpdf_tilingpattern.h" |
-#include "core/fpdfapi/page/pageint.h" |
-#include "core/fpdfapi/parser/cpdf_array.h" |
-#include "core/fpdfapi/parser/cpdf_dictionary.h" |
-#include "core/fpdfapi/parser/cpdf_document.h" |
-#include "core/fpdfdoc/cpdf_occontext.h" |
-#include "core/fxcodec/fx_codec.h" |
-#include "core/fxcrt/fx_safe_types.h" |
-#include "core/fxge/cfx_fxgedevice.h" |
-#include "core/fxge/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()->GetDirectObjectFor( |
- "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()->GetDirectObjectFor( |
- "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) { |
- FX_SAFE_SIZE_T image_size = m_pDIBSource->GetBPP(); |
- image_size /= 8; |
- image_size *= m_pDIBSource->GetWidth(); |
- image_size *= m_pDIBSource->GetHeight(); |
- if (!image_size.IsValid()) { |
- return FALSE; |
- } |
- |
- if (image_size.ValueOrDie() > 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->GetStreamFor("G"); |
- if (!pGroup) |
- return nullptr; |
- |
- std::unique_ptr<CPDF_Function> pFunc; |
- CPDF_Object* pFuncObj = pSMaskDict->GetDirectObjectFor("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->GetStringFor("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(); |
- int color_space_family = 0; |
- if (bLuminosity) { |
- CPDF_Array* pBC = pSMaskDict->GetArrayFor("BC"); |
- FX_ARGB back_color = 0xff000000; |
- if (pBC) { |
- CPDF_Object* pCSObj = nullptr; |
- CPDF_Dictionary* pDict = pGroup->GetDict(); |
- if (pDict && pDict->GetDictFor("Group")) { |
- pCSObj = pDict->GetDictFor("Group")->GetDirectObjectFor("CS"); |
- } |
- const CPDF_ColorSpace* pCS = |
- m_pContext->GetDocument()->LoadColorSpace(pCSObj); |
- if (pCS) { |
- // Store Color Space Family to use in CPDF_RenderStatus::Initialize. |
- color_space_family = pCS->GetFamily(); |
- |
- 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->GetDictFor("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, color_space_family, 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(); |
-} |