1 // Copyright 2016 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 "core/fpdfapi/render/cpdf_imagerenderer.h"
8
9 #include <algorithm>
10 #include <memory>
11
12 #include "core/fpdfapi/page/cpdf_dib.h"
13 #include "core/fpdfapi/page/cpdf_docpagedata.h"
14 #include "core/fpdfapi/page/cpdf_image.h"
15 #include "core/fpdfapi/page/cpdf_imageobject.h"
16 #include "core/fpdfapi/page/cpdf_occontext.h"
17 #include "core/fpdfapi/page/cpdf_page.h"
18 #include "core/fpdfapi/page/cpdf_pageobject.h"
19 #include "core/fpdfapi/page/cpdf_shadingpattern.h"
20 #include "core/fpdfapi/page/cpdf_tilingpattern.h"
21 #include "core/fpdfapi/page/cpdf_transferfunc.h"
22 #include "core/fpdfapi/parser/cpdf_dictionary.h"
23 #include "core/fpdfapi/parser/cpdf_document.h"
24 #include "core/fpdfapi/parser/cpdf_stream.h"
25 #include "core/fpdfapi/parser/fpdf_parser_decode.h"
26 #include "core/fpdfapi/render/cpdf_pagerendercache.h"
27 #include "core/fpdfapi/render/cpdf_rendercontext.h"
28 #include "core/fpdfapi/render/cpdf_renderstatus.h"
29 #include "core/fxcrt/fx_safe_types.h"
30 #include "core/fxcrt/maybe_owned.h"
31 #include "core/fxge/cfx_defaultrenderdevice.h"
32 #include "core/fxge/cfx_fillrenderoptions.h"
33 #include "core/fxge/cfx_pathdata.h"
34 #include "core/fxge/dib/cfx_dibbase.h"
35 #include "core/fxge/dib/cfx_dibitmap.h"
36 #include "core/fxge/dib/cfx_imagestretcher.h"
37 #include "core/fxge/dib/cfx_imagetransformer.h"
38 #include "third_party/base/notreached.h"
39 #include "third_party/base/stl_util.h"
40
41 #if defined(_SKIA_SUPPORT_)
42 #include "core/fxge/skia/fx_skia_device.h"
43 #endif
44
45 namespace {
46
IsImageValueTooBig(int val)47 bool IsImageValueTooBig(int val) {
48 // Likely large enough for any real rendering need, but sufficiently small
49 // that operations like val1 + val2 or -val will not overflow.
50 constexpr int kLimit = 256 * 1024 * 1024;
51 FX_SAFE_INT32 safe_val = val;
52 safe_val = safe_val.Abs();
53 return safe_val.ValueOrDefault(kLimit) >= kLimit;
54 }
55
56 } // namespace
57
58 CPDF_ImageRenderer::CPDF_ImageRenderer() = default;
59
60 CPDF_ImageRenderer::~CPDF_ImageRenderer() = default;
61
StartLoadDIBBase()62 bool CPDF_ImageRenderer::StartLoadDIBBase() {
63 if (!GetUnitRect().has_value())
64 return false;
65
66 if (!m_Loader.Start(m_pImageObject.Get(), m_pRenderStatus.Get(), m_bStdCS))
67 return false;
68
69 m_Mode = Mode::kDefault;
70 return true;
71 }
72
StartRenderDIBBase()73 bool CPDF_ImageRenderer::StartRenderDIBBase() {
74 if (!m_Loader.GetBitmap())
75 return false;
76
77 CPDF_GeneralState& state = m_pImageObject->m_GeneralState;
78 m_BitmapAlpha = FXSYS_roundf(255 * state.GetFillAlpha());
79 m_pDIBBase = m_Loader.GetBitmap();
80 if (GetRenderOptions().ColorModeIs(CPDF_RenderOptions::kAlpha) &&
81 !m_Loader.GetMask()) {
82 return StartBitmapAlpha();
83 }
84 if (state.GetTR()) {
85 if (!state.GetTransferFunc())
86 state.SetTransferFunc(m_pRenderStatus->GetTransferFunc(state.GetTR()));
87
88 if (state.GetTransferFunc() && !state.GetTransferFunc()->GetIdentity())
89 m_pDIBBase = m_Loader.TranslateImage(state.GetTransferFunc());
90 }
91 m_FillArgb = 0;
92 m_bPatternColor = false;
93 m_pPattern = nullptr;
94 if (m_pDIBBase->IsMask()) {
95 const CPDF_Color* pColor = m_pImageObject->m_ColorState.GetFillColor();
96 if (pColor && pColor->IsPattern()) {
97 m_pPattern.Reset(pColor->GetPattern());
98 if (m_pPattern)
99 m_bPatternColor = true;
100 }
101 m_FillArgb = m_pRenderStatus->GetFillArgb(m_pImageObject.Get());
102 } else if (GetRenderOptions().ColorModeIs(CPDF_RenderOptions::kGray)) {
103 RetainPtr<CFX_DIBitmap> pClone = m_pDIBBase->Clone(nullptr);
104 if (!pClone)
105 return false;
106
107 pClone->ConvertColorScale(0xffffff, 0);
108 m_pDIBBase = pClone;
109 }
110 m_ResampleOptions = FXDIB_ResampleOptions();
111 if (GetRenderOptions().GetOptions().bForceHalftone)
112 m_ResampleOptions.bHalftone = true;
113
114 if (m_pRenderStatus->GetRenderDevice()->GetDeviceType() !=
115 DeviceType::kDisplay) {
116 HandleFilters();
117 }
118
119 if (GetRenderOptions().GetOptions().bNoImageSmooth)
120 m_ResampleOptions.bNoSmoothing = true;
121 else if (m_pImageObject->GetImage()->IsInterpol())
122 m_ResampleOptions.bInterpolateBilinear = true;
123
124 if (m_Loader.GetMask())
125 return DrawMaskedImage();
126
127 if (m_bPatternColor)
128 return DrawPatternImage();
129
130 if (m_BitmapAlpha != 255 || !state.HasRef() || !state.GetFillOP() ||
131 state.GetOPMode() != 0 || state.GetBlendType() != BlendMode::kNormal ||
132 state.GetStrokeAlpha() != 1.0f || state.GetFillAlpha() != 1.0f) {
133 return StartDIBBase();
134 }
135 CPDF_Document* pDocument = nullptr;
136 CPDF_Page* pPage = nullptr;
137 if (auto* pPageCache = m_pRenderStatus->GetContext()->GetPageCache()) {
138 pPage = pPageCache->GetPage();
139 pDocument = pPage->GetDocument();
140 } else {
141 pDocument = m_pImageObject->GetImage()->GetDocument();
142 }
143 CPDF_Dictionary* pPageResources =
144 pPage ? pPage->m_pPageResources.Get() : nullptr;
145 CPDF_Object* pCSObj =
146 m_pImageObject->GetImage()->GetStream()->GetDict()->GetDirectObjectFor(
147 "ColorSpace");
148 auto* pData = CPDF_DocPageData::FromDocument(pDocument);
149 RetainPtr<CPDF_ColorSpace> pColorSpace =
150 pData->GetColorSpace(pCSObj, pPageResources);
151 if (pColorSpace) {
152 int format = pColorSpace->GetFamily();
153 if (format == PDFCS_DEVICECMYK || format == PDFCS_SEPARATION ||
154 format == PDFCS_DEVICEN) {
155 m_BlendType = BlendMode::kDarken;
156 }
157 }
158 return StartDIBBase();
159 }
160
Start(CPDF_RenderStatus * pStatus,CPDF_ImageObject * pImageObject,const CFX_Matrix & mtObj2Device,bool bStdCS,BlendMode blendType)161 bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
162 CPDF_ImageObject* pImageObject,
163 const CFX_Matrix& mtObj2Device,
164 bool bStdCS,
165 BlendMode blendType) {
166 ASSERT(pImageObject);
167 m_pRenderStatus = pStatus;
168 m_bStdCS = bStdCS;
169 m_pImageObject = pImageObject;
170 m_BlendType = blendType;
171 m_mtObj2Device = mtObj2Device;
172 const CPDF_Dictionary* pOC = m_pImageObject->GetImage()->GetOC();
173 if (pOC && GetRenderOptions().GetOCContext() &&
174 !GetRenderOptions().GetOCContext()->CheckOCGVisible(pOC)) {
175 return false;
176 }
177 m_ImageMatrix = m_pImageObject->matrix() * mtObj2Device;
178 if (StartLoadDIBBase())
179 return true;
180 return StartRenderDIBBase();
181 }
182
Start(CPDF_RenderStatus * pStatus,const RetainPtr<CFX_DIBBase> & pDIBBase,FX_ARGB bitmap_argb,const CFX_Matrix & mtImage2Device,const FXDIB_ResampleOptions & options,bool bStdCS)183 bool CPDF_ImageRenderer::Start(CPDF_RenderStatus* pStatus,
184 const RetainPtr<CFX_DIBBase>& pDIBBase,
185 FX_ARGB bitmap_argb,
186 const CFX_Matrix& mtImage2Device,
187 const FXDIB_ResampleOptions& options,
188 bool bStdCS) {
189 m_pRenderStatus = pStatus;
190 m_pDIBBase = pDIBBase;
191 m_FillArgb = bitmap_argb;
192 m_BitmapAlpha = 255;
193 m_ImageMatrix = mtImage2Device;
194 m_ResampleOptions = options;
195 m_bStdCS = bStdCS;
196 m_BlendType = BlendMode::kNormal;
197 return StartDIBBase();
198 }
199
NotDrawing() const200 bool CPDF_ImageRenderer::NotDrawing() const {
201 return m_pRenderStatus->IsPrint() &&
202 !(m_pRenderStatus->GetRenderDevice()->GetRenderCaps() &
203 FXRC_BLEND_MODE);
204 }
205
GetDrawRect() const206 FX_RECT CPDF_ImageRenderer::GetDrawRect() const {
207 FX_RECT rect = m_ImageMatrix.GetUnitRect().GetOuterRect();
208 rect.Intersect(m_pRenderStatus->GetRenderDevice()->GetClipBox());
209 return rect;
210 }
211
GetDrawMatrix(const FX_RECT & rect) const212 CFX_Matrix CPDF_ImageRenderer::GetDrawMatrix(const FX_RECT& rect) const {
213 CFX_Matrix new_matrix = m_ImageMatrix;
214 new_matrix.Translate(-rect.left, -rect.top);
215 return new_matrix;
216 }
217
CalculateDrawImage(CFX_DefaultRenderDevice * pBitmapDevice1,CFX_DefaultRenderDevice * pBitmapDevice2,const RetainPtr<CFX_DIBBase> & pDIBBase,const CFX_Matrix & mtNewMatrix,const FX_RECT & rect) const218 void CPDF_ImageRenderer::CalculateDrawImage(
219 CFX_DefaultRenderDevice* pBitmapDevice1,
220 CFX_DefaultRenderDevice* pBitmapDevice2,
221 const RetainPtr<CFX_DIBBase>& pDIBBase,
222 const CFX_Matrix& mtNewMatrix,
223 const FX_RECT& rect) const {
224 CPDF_RenderStatus bitmap_render(m_pRenderStatus->GetContext(),
225 pBitmapDevice2);
226 bitmap_render.SetDropObjects(m_pRenderStatus->GetDropObjects());
227 bitmap_render.SetStdCS(true);
228 bitmap_render.Initialize(nullptr, nullptr);
229
230 CPDF_ImageRenderer image_render;
231 if (image_render.Start(&bitmap_render, pDIBBase, 0xffffffff, mtNewMatrix,
232 m_ResampleOptions, true)) {
233 image_render.Continue(nullptr);
234 }
235 if (m_Loader.MatteColor() == 0xffffffff)
236 return;
237 int matte_r = FXARGB_R(m_Loader.MatteColor());
238 int matte_g = FXARGB_G(m_Loader.MatteColor());
239 int matte_b = FXARGB_B(m_Loader.MatteColor());
240 for (int row = 0; row < rect.Height(); row++) {
241 uint8_t* dest_scan = pBitmapDevice1->GetBitmap()->GetWritableScanline(row);
242 const uint8_t* mask_scan = pBitmapDevice2->GetBitmap()->GetScanline(row);
243 for (int col = 0; col < rect.Width(); col++) {
244 int alpha = *mask_scan++;
245 if (!alpha) {
246 dest_scan += 4;
247 continue;
248 }
249 int orig = (*dest_scan - matte_b) * 255 / alpha + matte_b;
250 *dest_scan++ = pdfium::clamp(orig, 0, 255);
251 orig = (*dest_scan - matte_g) * 255 / alpha + matte_g;
252 *dest_scan++ = pdfium::clamp(orig, 0, 255);
253 orig = (*dest_scan - matte_r) * 255 / alpha + matte_r;
254 *dest_scan++ = pdfium::clamp(orig, 0, 255);
255 dest_scan++;
256 }
257 }
258 }
259
GetRenderOptions() const260 const CPDF_RenderOptions& CPDF_ImageRenderer::GetRenderOptions() const {
261 return m_pRenderStatus->GetRenderOptions();
262 }
263
DrawPatternImage()264 bool CPDF_ImageRenderer::DrawPatternImage() {
265 if (NotDrawing()) {
266 m_Result = false;
267 return false;
268 }
269
270 FX_RECT rect = GetDrawRect();
271 if (rect.IsEmpty())
272 return false;
273
274 CFX_Matrix new_matrix = GetDrawMatrix(rect);
275 CFX_DefaultRenderDevice bitmap_device1;
276 if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Format::kRgb32,
277 nullptr)) {
278 return true;
279 }
280 bitmap_device1.GetBitmap()->Clear(0xffffff);
281
282 CPDF_RenderStatus bitmap_render(m_pRenderStatus->GetContext(),
283 &bitmap_device1);
284 bitmap_render.SetOptions(GetRenderOptions());
285 bitmap_render.SetDropObjects(m_pRenderStatus->GetDropObjects());
286 bitmap_render.SetStdCS(true);
287 bitmap_render.Initialize(nullptr, nullptr);
288
289 CFX_Matrix patternDevice = m_mtObj2Device;
290 patternDevice.Translate(static_cast<float>(-rect.left),
291 static_cast<float>(-rect.top));
292 if (CPDF_TilingPattern* pTilingPattern = m_pPattern->AsTilingPattern()) {
293 bitmap_render.DrawTilingPattern(pTilingPattern, m_pImageObject.Get(),
294 patternDevice, false);
295 } else if (CPDF_ShadingPattern* pShadingPattern =
296 m_pPattern->AsShadingPattern()) {
297 bitmap_render.DrawShadingPattern(pShadingPattern, m_pImageObject.Get(),
298 patternDevice, false);
299 }
300
301 CFX_DefaultRenderDevice bitmap_device2;
302 if (!bitmap_device2.Create(rect.Width(), rect.Height(),
303 FXDIB_Format::k8bppRgb, nullptr)) {
304 return true;
305 }
306 bitmap_device2.GetBitmap()->Clear(0);
307 CalculateDrawImage(&bitmap_device1, &bitmap_device2, m_pDIBBase, new_matrix,
308 rect);
309 bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_Format::k8bppMask);
310 bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
311 bitmap_device1.GetBitmap()->MultiplyAlpha(255);
312 m_pRenderStatus->GetRenderDevice()->SetDIBitsWithBlend(
313 bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
314 return false;
315 }
316
DrawMaskedImage()317 bool CPDF_ImageRenderer::DrawMaskedImage() {
318 if (NotDrawing()) {
319 m_Result = false;
320 return false;
321 }
322
323 FX_RECT rect = GetDrawRect();
324 if (rect.IsEmpty())
325 return false;
326
327 CFX_Matrix new_matrix = GetDrawMatrix(rect);
328 CFX_DefaultRenderDevice bitmap_device1;
329 if (!bitmap_device1.Create(rect.Width(), rect.Height(), FXDIB_Format::kRgb32,
330 nullptr)) {
331 return true;
332 }
333 #if defined(_SKIA_SUPPORT_)
334 bitmap_device1.Clear(0xffffff);
335 #else
336 bitmap_device1.GetBitmap()->Clear(0xffffff);
337 #endif
338 CPDF_RenderStatus bitmap_render(m_pRenderStatus->GetContext(),
339 &bitmap_device1);
340 bitmap_render.SetDropObjects(m_pRenderStatus->GetDropObjects());
341 bitmap_render.SetStdCS(true);
342 bitmap_render.Initialize(nullptr, nullptr);
343 CPDF_ImageRenderer image_render;
344 if (image_render.Start(&bitmap_render, m_pDIBBase, 0, new_matrix,
345 m_ResampleOptions, true)) {
346 image_render.Continue(nullptr);
347 }
348 CFX_DefaultRenderDevice bitmap_device2;
349 if (!bitmap_device2.Create(rect.Width(), rect.Height(),
350 FXDIB_Format::k8bppRgb, nullptr)) {
351 return true;
352 }
353 #if defined(_SKIA_SUPPORT_)
354 bitmap_device2.Clear(0);
355 #else
356 bitmap_device2.GetBitmap()->Clear(0);
357 #endif
358 CalculateDrawImage(&bitmap_device1, &bitmap_device2, m_Loader.GetMask(),
359 new_matrix, rect);
360 #if defined(_SKIA_SUPPORT_)
361 m_pRenderStatus->GetRenderDevice()->SetBitsWithMask(
362 bitmap_device1.GetBitmap(), bitmap_device2.GetBitmap(), rect.left,
363 rect.top, m_BitmapAlpha, m_BlendType);
364 #else
365 bitmap_device2.GetBitmap()->ConvertFormat(FXDIB_Format::k8bppMask);
366 bitmap_device1.GetBitmap()->MultiplyAlpha(bitmap_device2.GetBitmap());
367 if (m_BitmapAlpha < 255)
368 bitmap_device1.GetBitmap()->MultiplyAlpha(m_BitmapAlpha);
369 m_pRenderStatus->GetRenderDevice()->SetDIBitsWithBlend(
370 bitmap_device1.GetBitmap(), rect.left, rect.top, m_BlendType);
371 #endif // defined(_SKIA_SUPPORT_)
372 return false;
373 }
374
StartDIBBase()375 bool CPDF_ImageRenderer::StartDIBBase() {
376 if (m_pDIBBase->GetBPP() > 1) {
377 FX_SAFE_SIZE_T image_size = m_pDIBBase->GetBPP();
378 image_size /= 8;
379 image_size *= m_pDIBBase->GetWidth();
380 image_size *= m_pDIBBase->GetHeight();
381 if (!image_size.IsValid())
382 return false;
383
384 if (image_size.ValueOrDie() > kHugeImageSize &&
385 !m_ResampleOptions.bHalftone) {
386 m_ResampleOptions.bInterpolateBilinear = true;
387 }
388 }
389 #if defined(_SKIA_SUPPORT_)
390 RetainPtr<CFX_DIBitmap> premultiplied = m_pDIBBase->Clone(nullptr);
391 if (m_pDIBBase->HasAlpha())
392 CFX_SkiaDeviceDriver::PreMultiply(premultiplied);
393 if (m_pRenderStatus->GetRenderDevice()->StartDIBitsWithBlend(
394 premultiplied, m_BitmapAlpha, m_FillArgb, m_ImageMatrix,
395 m_ResampleOptions, &m_DeviceHandle, m_BlendType)) {
396 if (m_DeviceHandle) {
397 m_Mode = Mode::kBlend;
398 return true;
399 }
400 return false;
401 }
402 #else
403 if (m_pRenderStatus->GetRenderDevice()->StartDIBitsWithBlend(
404 m_pDIBBase, m_BitmapAlpha, m_FillArgb, m_ImageMatrix,
405 m_ResampleOptions, &m_DeviceHandle, m_BlendType)) {
406 if (m_DeviceHandle) {
407 m_Mode = Mode::kBlend;
408 return true;
409 }
410 return false;
411 }
412 #endif // defined(_SKIA_SUPPORT_)
413
414 if ((fabs(m_ImageMatrix.b) >= 0.5f || m_ImageMatrix.a == 0) ||
415 (fabs(m_ImageMatrix.c) >= 0.5f || m_ImageMatrix.d == 0)) {
416 if (NotDrawing()) {
417 m_Result = false;
418 return false;
419 }
420
421 Optional<FX_RECT> image_rect = GetUnitRect();
422 if (!image_rect.has_value())
423 return false;
424
425 FX_RECT clip_box = m_pRenderStatus->GetRenderDevice()->GetClipBox();
426 clip_box.Intersect(image_rect.value());
427 m_Mode = Mode::kTransform;
428 m_pTransformer = std::make_unique<CFX_ImageTransformer>(
429 m_pDIBBase, m_ImageMatrix, m_ResampleOptions, &clip_box);
430 return true;
431 }
432
433 Optional<FX_RECT> image_rect = GetUnitRect();
434 if (!image_rect.has_value())
435 return false;
436
437 int dest_left;
438 int dest_top;
439 int dest_width;
440 int dest_height;
441 if (!GetDimensionsFromUnitRect(image_rect.value(), &dest_left, &dest_top,
442 &dest_width, &dest_height)) {
443 return false;
444 }
445
446 if (m_pDIBBase->IsOpaqueImage() && m_BitmapAlpha == 255) {
447 if (m_pRenderStatus->GetRenderDevice()->StretchDIBitsWithFlagsAndBlend(
448 m_pDIBBase, dest_left, dest_top, dest_width, dest_height,
449 m_ResampleOptions, m_BlendType)) {
450 return false;
451 }
452 }
453 if (m_pDIBBase->IsMask()) {
454 if (m_BitmapAlpha != 255)
455 m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
456 if (m_pRenderStatus->GetRenderDevice()->StretchBitMaskWithFlags(
457 m_pDIBBase, dest_left, dest_top, dest_width, dest_height,
458 m_FillArgb, m_ResampleOptions)) {
459 return false;
460 }
461 }
462 if (NotDrawing()) {
463 m_Result = false;
464 return true;
465 }
466
467 FX_RECT clip_box = m_pRenderStatus->GetRenderDevice()->GetClipBox();
468 FX_RECT dest_rect = clip_box;
469 dest_rect.Intersect(image_rect.value());
470 FX_RECT dest_clip(
471 dest_rect.left - image_rect->left, dest_rect.top - image_rect->top,
472 dest_rect.right - image_rect->left, dest_rect.bottom - image_rect->top);
473 RetainPtr<CFX_DIBitmap> pStretched = m_pDIBBase->StretchTo(
474 dest_width, dest_height, m_ResampleOptions, &dest_clip);
475 if (pStretched) {
476 m_pRenderStatus->CompositeDIBitmap(pStretched, dest_rect.left,
477 dest_rect.top, m_FillArgb, m_BitmapAlpha,
478 m_BlendType, CPDF_Transparency());
479 }
480 return false;
481 }
482
StartBitmapAlpha()483 bool CPDF_ImageRenderer::StartBitmapAlpha() {
484 if (m_pDIBBase->IsOpaqueImage()) {
485 CFX_PathData path;
486 path.AppendRect(0, 0, 1, 1);
487 path.Transform(m_ImageMatrix);
488 uint32_t fill_color =
489 ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha);
490 m_pRenderStatus->GetRenderDevice()->DrawPath(
491 &path, nullptr, nullptr, fill_color, 0,
492 CFX_FillRenderOptions::WindingOptions());
493 return false;
494 }
495 RetainPtr<CFX_DIBBase> pAlphaMask;
496 if (m_pDIBBase->IsMask())
497 pAlphaMask = m_pDIBBase;
498 else
499 pAlphaMask = m_pDIBBase->CloneAlphaMask();
500
501 if (fabs(m_ImageMatrix.b) >= 0.5f || fabs(m_ImageMatrix.c) >= 0.5f) {
502 int left;
503 int top;
504 RetainPtr<CFX_DIBitmap> pTransformed =
505 pAlphaMask->TransformTo(m_ImageMatrix, &left, &top);
506 if (!pTransformed)
507 return true;
508
509 m_pRenderStatus->GetRenderDevice()->SetBitMask(
510 pTransformed, left, top,
511 ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
512 return false;
513 }
514
515 Optional<FX_RECT> image_rect = GetUnitRect();
516 if (!image_rect.has_value())
517 return false;
518
519 int left;
520 int top;
521 int dest_width;
522 int dest_height;
523 if (!GetDimensionsFromUnitRect(image_rect.value(), &left, &top, &dest_width,
524 &dest_height)) {
525 return false;
526 }
527
528 m_pRenderStatus->GetRenderDevice()->StretchBitMask(
529 pAlphaMask, left, top, dest_width, dest_height,
530 ArgbEncode(0xff, m_BitmapAlpha, m_BitmapAlpha, m_BitmapAlpha));
531 return false;
532 }
533
Continue(PauseIndicatorIface * pPause)534 bool CPDF_ImageRenderer::Continue(PauseIndicatorIface* pPause) {
535 switch (m_Mode) {
536 case Mode::kNone:
537 return false;
538 case Mode::kDefault:
539 return ContinueDefault(pPause);
540 case Mode::kBlend:
541 return ContinueBlend(pPause);
542 case Mode::kTransform:
543 return ContinueTransform(pPause);
544 }
545 NOTREACHED();
546 return false;
547 }
548
ContinueDefault(PauseIndicatorIface * pPause)549 bool CPDF_ImageRenderer::ContinueDefault(PauseIndicatorIface* pPause) {
550 if (m_Loader.Continue(pPause, m_pRenderStatus.Get()))
551 return true;
552
553 if (!StartRenderDIBBase())
554 return false;
555
556 if (m_Mode == Mode::kDefault)
557 return false;
558
559 return Continue(pPause);
560 }
561
ContinueBlend(PauseIndicatorIface * pPause)562 bool CPDF_ImageRenderer::ContinueBlend(PauseIndicatorIface* pPause) {
563 return m_pRenderStatus->GetRenderDevice()->ContinueDIBits(
564 m_DeviceHandle.get(), pPause);
565 }
566
ContinueTransform(PauseIndicatorIface * pPause)567 bool CPDF_ImageRenderer::ContinueTransform(PauseIndicatorIface* pPause) {
568 if (m_pTransformer->Continue(pPause))
569 return true;
570
571 RetainPtr<CFX_DIBitmap> pBitmap = m_pTransformer->DetachBitmap();
572 if (!pBitmap)
573 return false;
574
575 if (pBitmap->IsMask()) {
576 if (m_BitmapAlpha != 255)
577 m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
578 m_Result = m_pRenderStatus->GetRenderDevice()->SetBitMask(
579 pBitmap, m_pTransformer->result().left, m_pTransformer->result().top,
580 m_FillArgb);
581 } else {
582 if (m_BitmapAlpha != 255)
583 pBitmap->MultiplyAlpha(m_BitmapAlpha);
584 m_Result = m_pRenderStatus->GetRenderDevice()->SetDIBitsWithBlend(
585 pBitmap, m_pTransformer->result().left, m_pTransformer->result().top,
586 m_BlendType);
587 }
588 return false;
589 }
590
HandleFilters()591 void CPDF_ImageRenderer::HandleFilters() {
592 Optional<DecoderArray> decoder_array =
593 GetDecoderArray(m_pImageObject->GetImage()->GetStream()->GetDict());
594 if (!decoder_array.has_value())
595 return;
596
597 for (const auto& decoder : decoder_array.value()) {
598 if (decoder.first == "DCTDecode" || decoder.first == "JPXDecode") {
599 m_ResampleOptions.bLossy = true;
600 return;
601 }
602 }
603 }
604
GetUnitRect() const605 Optional<FX_RECT> CPDF_ImageRenderer::GetUnitRect() const {
606 CFX_FloatRect image_rect_f = m_ImageMatrix.GetUnitRect();
607 FX_RECT image_rect = image_rect_f.GetOuterRect();
608 if (!image_rect.Valid())
609 return {};
610 return image_rect;
611 }
612
GetDimensionsFromUnitRect(const FX_RECT & rect,int * left,int * top,int * width,int * height) const613 bool CPDF_ImageRenderer::GetDimensionsFromUnitRect(const FX_RECT& rect,
614 int* left,
615 int* top,
616 int* width,
617 int* height) const {
618 ASSERT(rect.Valid());
619
620 int dest_width = rect.Width();
621 int dest_height = rect.Height();
622 if (IsImageValueTooBig(dest_width) || IsImageValueTooBig(dest_height))
623 return false;
624
625 if (m_ImageMatrix.a < 0)
626 dest_width = -dest_width;
627
628 if (m_ImageMatrix.d > 0)
629 dest_height = -dest_height;
630
631 int dest_left = dest_width > 0 ? rect.left : rect.right;
632 int dest_top = dest_height > 0 ? rect.top : rect.bottom;
633 if (IsImageValueTooBig(dest_left) || IsImageValueTooBig(dest_top))
634 return false;
635
636 *left = dest_left;
637 *top = dest_top;
638 *width = dest_width;
639 *height = dest_height;
640 return true;
641 }
642