blob: c7334f6ad3550e76d4df8ca98941b2f0a7eedcba [file] [log] [blame]
// Copyright 2016 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/render/cpdf_imagerenderer.h"
#include <algorithm>
#include <memory>
#include "core/fpdfapi/page/cpdf_docpagedata.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_pageobject.h"
#include "core/fpdfapi/page/cpdf_shadingpattern.h"
#include "core/fpdfapi/page/cpdf_tilingpattern.h"
#include "core/fpdfapi/parser/cpdf_array.h"
#include "core/fpdfapi/parser/cpdf_dictionary.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/render/cpdf_dibsource.h"
#include "core/fpdfapi/render/cpdf_pagerendercache.h"
#include "core/fpdfapi/render/cpdf_rendercontext.h"
#include "core/fpdfapi/render/cpdf_renderstatus.h"
#include "core/fpdfapi/render/cpdf_transferfunc.h"
#include "core/fpdfdoc/cpdf_occontext.h"
#include "core/fxcrt/fx_safe_types.h"
#include "core/fxcrt/maybe_owned.h"
#include "core/fxge/cfx_defaultrenderdevice.h"
#include "core/fxge/cfx_pathdata.h"
#include "core/fxge/dib/cfx_dibitmap.h"
#include "core/fxge/dib/cfx_dibsource.h"
#include "core/fxge/dib/cfx_imagestretcher.h"
#include "core/fxge/dib/cfx_imagetransformer.h"
#include "third_party/base/ptr_util.h"
#include "third_party/base/stl_util.h"
#ifdef _SKIA_SUPPORT_
#include "core/fxge/skia/fx_skia_device.h"
#endif
CPDF_ImageRenderer::CPDF_ImageRenderer()
: m_pRenderStatus(nullptr),
m_pImageObject(nullptr),
m_Status(0),
m_pObj2Device(nullptr),
m_bPatternColor(false),
m_pPattern(nullptr),
m_bStdCS(false),
m_BlendType(FXDIB_BLEND_NORMAL),
m_Result(true) {}
CPDF_ImageRenderer::~CPDF_ImageRenderer() {}
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;
if (m_Loader.Start(m_pImageObject.Get(),
m_pRenderStatus->GetContext()->GetPageCache(), m_bStdCS,
m_pRenderStatus->GetGroupFamily(),
m_pRenderStatus->GetLoadMask(), m_pRenderStatus.Get())) {
m_Status = 4;
return true;
}
return false;
}
bool CPDF_ImageRenderer::StartRenderDIBSource() {
if (!m_Loader.m_pBitmap)
return false;
CPDF_GeneralState& state = m_pImageObject->m_GeneralState;
m_BitmapAlpha = FXSYS_round(255 * state.GetFillAlpha());
m_pDIBSource = m_Loader.m_pBitmap;
if (m_pRenderStatus->GetRenderOptions()->ColorModeIs(
CPDF_RenderOptions::kAlpha) &&
!m_Loader.m_pMask) {
return StartBitmapAlpha();
}
if (state.GetTR()) {
if (!state.GetTransferFunc())
state.SetTransferFunc(m_pRenderStatus->GetTransferFunc(state.GetTR()));
if (state.GetTransferFunc() && !state.GetTransferFunc()->GetIdentity()) {
m_pDIBSource = m_Loader.m_pBitmap =
state.GetTransferFunc()->TranslateImage(m_Loader.m_pBitmap);
if (m_Loader.m_bCached && m_Loader.m_pMask)
m_Loader.m_pMask = m_Loader.m_pMask->Clone(nullptr);
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.Get());
} else if (m_pRenderStatus->GetRenderOptions()->ColorModeIs(
CPDF_RenderOptions::kGray)) {
RetainPtr<CFX_DIBitmap> pClone = m_pDIBSource->Clone(nullptr);
if (!pClone)
return false;
pClone->ConvertColorScale(0xffffff, 0);
m_pDIBSource = pClone;
}
m_Flags = 0;
if (m_pRenderStatus->GetRenderOptions()->HasFlag(RENDER_FORCE_DOWNSAMPLE))
m_Flags |= RENDER_FORCE_DOWNSAMPLE;
else if (m_pRenderStatus->GetRenderOptions()->HasFlag(RENDER_FORCE_HALFTONE))
m_Flags |= RENDER_FORCE_HALFTONE;
if (m_pRenderStatus->GetRenderDevice()->GetDeviceClass() != FXDC_DISPLAY)
HandleFilters();
if (m_pRenderStatus->GetRenderOptions()->HasFlag(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.Get());
if (m_BitmapAlpha != 255 || !state.HasRef() || !state.GetFillOP() ||
state.GetOPMode() != 0 || state.GetBlendType() != FXDIB_BLEND_NORMAL ||
state.GetStrokeAlpha() != 1.0f || state.GetFillAlpha() != 1.0f) {
return StartDIBSource();
}
CPDF_Document* pDocument = nullptr;
CPDF_Page* pPage = nullptr;
if (auto* pPageCache = m_pRenderStatus->GetContext()->GetPageCache()) {
pPage = pPageCache->GetPage();
pDocument = pPage->GetDocument();
} else {
pDocument = m_pImageObject->GetImage()->GetDocument();
}
CPDF_Dictionary* pPageResources =
pPage ? pPage->m_pPageResources.Get() : nullptr;
CPDF_Object* pCSObj =
m_pImageObject->GetImage()->GetStream()->GetDict()->GetDirectObjectFor(
"ColorSpace");
CPDF_ColorSpace* pColorSpace =
pDocument->LoadColorSpace(pCSObj, pPageResources);
if (!pColorSpace)
return StartDIBSource();
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();
}
bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
CPDF_ImageObject* pImageObject,
const CFX_Matrix* pObj2Device,
bool bStdCS,
int blendType) {
ASSERT(pImageObject);
m_pRenderStatus = pStatus;
m_bStdCS = bStdCS;
m_pImageObject = pImageObject;
m_BlendType = blendType;
m_pObj2Device = pObj2Device;
const CPDF_Dictionary* pOC = m_pImageObject->GetImage()->GetOC();
if (pOC && m_pRenderStatus->GetRenderOptions()->GetOCContext() &&
!m_pRenderStatus->GetRenderOptions()->GetOCContext()->CheckOCGVisible(
pOC)) {
return false;
}
m_ImageMatrix = m_pImageObject->matrix();
m_ImageMatrix.Concat(*pObj2Device);
if (StartLoadDIBSource())
return true;
return StartRenderDIBSource();
}
bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
const RetainPtr<CFX_DIBSource>& pDIBSource,
FX_ARGB bitmap_argb,
int bitmap_alpha,
const CFX_Matrix* pImage2Device,
uint32_t flags,
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();
}
bool CPDF_ImageRenderer::NotDrawing() const {
return m_pRenderStatus->IsPrint() &&
!(m_pRenderStatus->GetRenderDevice()->GetRenderCaps() &
FXRC_BLEND_MODE);
}
FX_RECT CPDF_ImageRenderer::GetDrawRect() const {
FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect();
rect.Intersect(m_pRenderStatus->GetRenderDevice()->GetClipBox());
return rect;
}
CFX_Matrix CPDF_ImageRenderer::GetDrawMatrix(const FX_RECT& rect) const {
CFX_Matrix new_matrix = m_ImageMatrix;
new_matrix.Translate(-rect.left, -rect.top);
return new_matrix;
}
void CPDF_ImageRenderer::CalculateDrawImage(
CFX_DefaultRenderDevice* pBitmapDevice1,
CFX_DefaultRenderDevice* pBitmapDevice2,
const RetainPtr<CFX_DIBSource>& pDIBSource,
CFX_Matrix* pNewMatrix,
const FX_RECT& rect) const {
CPDF_RenderStatus bitmap_render;
bitmap_render.Initialize(m_pRenderStatus->GetContext(), pBitmapDevice2,
nullptr, nullptr, nullptr, nullptr, nullptr,
CPDF_Transparency(),
m_pRenderStatus->GetDropObjects(), nullptr, true);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, pDIBSource, 0xffffffff, 255,
pNewMatrix, m_Flags, true, FXDIB_BLEND_NORMAL)) {
image_render.Continue(nullptr);
}
if (m_Loader.m_MatteColor == 0xffffffff)
return;
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 < rect.Height(); row++) {
uint8_t* dest_scan = pBitmapDevice1->GetBitmap()->GetWritableScanline(row);
const uint8_t* mask_scan = pBitmapDevice2->GetBitmap()->GetScanline(row);
for (int col = 0; col < rect.Width(); col++) {
int alpha = *mask_scan++;
if (!alpha) {
dest_scan += 4;
continue;
}
int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
*dest_scan++ = pdfium::clamp(orig, 0, 255);
orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
*dest_scan++ = pdfium::clamp(orig, 0, 255);
orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
*dest_scan++ = pdfium::clamp(orig, 0, 255);
dest_scan++;
}
}
}
bool CPDF_ImageRenderer::DrawPatternImage(const CFX_Matrix* pObj2Device) {
if (NotDrawing()) {
m_Result = false;
return false;
}
FX_RECT rect = GetDrawRect();
if (rect.IsEmpty())
return false;
CFX_Matrix new_matrix = GetDrawMatrix(rect);
CFX_DefaultRenderDevice 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->GetContext(), &bitmap_device1, nullptr, nullptr, nullptr,
nullptr, m_pRenderStatus->GetRenderOptions(), CPDF_Transparency(),
m_pRenderStatus->GetDropObjects(), nullptr, true);
CFX_Matrix patternDevice = *pObj2Device;
patternDevice.Translate(static_cast<float>(-rect.left),
static_cast<float>(-rect.top));
if (CPDF_TilingPattern* pTilingPattern = m_pPattern->AsTilingPattern()) {
bitmap_render.DrawTilingPattern(pTilingPattern, m_pImageObject.Get(),
&patternDevice, false);
} else if (CPDF_ShadingPattern* pShadingPattern =
m_pPattern->AsShadingPattern()) {
bitmap_render.DrawShadingPattern(pShadingPattern, m_pImageObject.Get(),
&patternDevice, false);
}
CFX_DefaultRenderDevice bitmap_device2;
if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb,
nullptr)) {
return true;
}
bitmap_device2.GetBitmap()->Clear(0);
CalculateDrawImage(&bitmap_device1, &bitmap_device2, m_pDIBSource,
&new_matrix, rect);
bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_8bppMask);
bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
bitmap_device1.GetBitmap()->MultiplyAlpha(255);
m_pRenderStatus->GetRenderDevice()->SetDIBitsWithBlend(
bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
return false;
}
bool CPDF_ImageRenderer::DrawMaskedImage() {
if (NotDrawing()) {
m_Result = false;
return false;
}
FX_RECT rect = GetDrawRect();
if (rect.IsEmpty())
return false;
CFX_Matrix new_matrix = GetDrawMatrix(rect);
CFX_DefaultRenderDevice bitmap_device1;
if (!bitmap_device1.Create(rect.Width(), rect.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->GetContext(), &bitmap_device1,
nullptr, nullptr, nullptr, nullptr, nullptr,
CPDF_Transparency(),
m_pRenderStatus->GetDropObjects(), nullptr, true);
CPDF_ImageRenderer image_render;
if (image_render.Start(&bitmap_render, m_pDIBSource, 0, 255, &new_matrix,
m_Flags, true, FXDIB_BLEND_NORMAL)) {
image_render.Continue(nullptr);
}
CFX_DefaultRenderDevice bitmap_device2;
if (!bitmap_device2.Create(rect.Width(), rect.Height(), FXDIB_8bppRgb,
nullptr))
return true;
#if defined _SKIA_SUPPORT_
bitmap_device2.Clear(0);
#else
bitmap_device2.GetBitmap()->Clear(0);
#endif
CalculateDrawImage(&bitmap_device1, &bitmap_device2, m_Loader.m_pMask,
&new_matrix, rect);
#ifdef _SKIA_SUPPORT_
m_pRenderStatus->GetRenderDevice()->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->GetRenderDevice()->SetDIBitsWithBlend(
bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
#endif // _SKIA_SUPPORT_
return false;
}
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_
RetainPtr<CFX_DIBitmap> premultiplied = m_pDIBSource->Clone(nullptr);
if (m_pDIBSource->HasAlpha())
CFX_SkiaDeviceDriver::PreMultiply(premultiplied);
if (m_pRenderStatus->GetRenderDevice()->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->GetRenderDevice()->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 ((fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
(fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0)) {
if (NotDrawing()) {
m_Result = false;
return false;
}
FX_RECT clip_box = m_pRenderStatus->GetRenderDevice()->GetClipBox();
clip_box.Intersect(image_rect);
m_Status = 2;
m_pTransformer = pdfium::MakeUnique<CFX_ImageTransformer>(
m_pDIBSource, &m_ImageMatrix, m_Flags, &clip_box);
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->GetRenderDevice()->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->GetRenderDevice()->StretchBitMaskWithFlags(
m_pDIBSource, dest_left, dest_top, dest_width, dest_height,
m_FillArgb, m_Flags)) {
return false;
}
}
if (NotDrawing()) {
m_Result = false;
return true;
}
FX_RECT clip_box = m_pRenderStatus->GetRenderDevice()->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);
RetainPtr<CFX_DIBitmap> pStretched =
m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip);
if (pStretched) {
m_pRenderStatus->CompositeDIBitmap(pStretched, dest_rect.left,
dest_rect.top, m_FillArgb, m_BitmapAlpha,
m_BlendType, CPDF_Transparency());
}
return false;
}
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->GetRenderDevice()->DrawPath(&path, nullptr, nullptr,
fill_color, 0, FXFILL_WINDING);
return false;
}
RetainPtr<CFX_DIBSource> pAlphaMask;
if (m_pDIBSource->IsAlphaMask())
pAlphaMask = m_pDIBSource;
else
pAlphaMask = m_pDIBSource->CloneAlphaMask();
if (fabs(m_ImageMatrix.b) >= 0.5f || fabs(m_ImageMatrix.c) >= 0.5f) {
int left;
int top;
RetainPtr<CFX_DIBitmap> pTransformed =
pAlphaMask->TransformTo(&m_ImageMatrix, &left, &top);
if (!pTransformed)
return true;
m_pRenderStatus->GetRenderDevice()->SetBitMask(
pTransformed, left, top,
ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
return false;
}
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->GetRenderDevice()->StretchBitMask(
pAlphaMask, left, top, dest_width, dest_height,
ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
return false;
}
bool CPDF_ImageRenderer::Continue(PauseIndicatorIface* pPause) {
if (m_Status == 2) {
if (m_pTransformer->Continue(pPause))
return true;
RetainPtr<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->GetRenderDevice()->SetBitMask(
pBitmap, m_pTransformer->result().left, m_pTransformer->result().top,
m_FillArgb);
} else {
if (m_BitmapAlpha != 255)
pBitmap->MultiplyAlpha(m_BitmapAlpha);
m_Result = m_pRenderStatus->GetRenderDevice()->SetDIBitsWithBlend(
pBitmap, m_pTransformer->result().left, m_pTransformer->result().top,
m_BlendType);
}
return false;
}
if (m_Status == 3) {
return m_pRenderStatus->GetRenderDevice()->ContinueDIBits(
m_DeviceHandle.get(), pPause);
}
if (m_Status == 4) {
if (m_Loader.Continue(pPause, m_pRenderStatus.Get()))
return true;
if (StartRenderDIBSource())
return Continue(pPause);
}
return false;
}
void CPDF_ImageRenderer::HandleFilters() {
CPDF_Object* pFilters =
m_pImageObject->GetImage()->GetStream()->GetDict()->GetDirectObjectFor(
"Filter");
if (!pFilters)
return;
if (pFilters->IsName()) {
ByteString bsDecodeType = pFilters->GetString();
if (bsDecodeType == "DCTDecode" || bsDecodeType == "JPXDecode")
m_Flags |= FXRENDER_IMAGE_LOSSY;
return;
}
CPDF_Array* pArray = pFilters->AsArray();
if (!pArray)
return;
for (size_t i = 0; i < pArray->GetCount(); i++) {
ByteString bsDecodeType = pArray->GetStringAt(i);
if (bsDecodeType == "DCTDecode" || bsDecodeType == "JPXDecode") {
m_Flags |= FXRENDER_IMAGE_LOSSY;
break;
}
}
}