1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "core/include/fxge/fx_ge.h"
8
CFX_RenderDevice()9 CFX_RenderDevice::CFX_RenderDevice() {
10 m_pDeviceDriver = NULL;
11 m_pBitmap = NULL;
12 }
~CFX_RenderDevice()13 CFX_RenderDevice::~CFX_RenderDevice() {
14 delete m_pDeviceDriver;
15 }
SetDeviceDriver(IFX_RenderDeviceDriver * pDriver)16 void CFX_RenderDevice::SetDeviceDriver(IFX_RenderDeviceDriver* pDriver) {
17 delete m_pDeviceDriver;
18 m_pDeviceDriver = pDriver;
19 InitDeviceInfo();
20 }
InitDeviceInfo()21 void CFX_RenderDevice::InitDeviceInfo() {
22 m_Width = m_pDeviceDriver->GetDeviceCaps(FXDC_PIXEL_WIDTH);
23 m_Height = m_pDeviceDriver->GetDeviceCaps(FXDC_PIXEL_HEIGHT);
24 m_bpp = m_pDeviceDriver->GetDeviceCaps(FXDC_BITS_PIXEL);
25 m_RenderCaps = m_pDeviceDriver->GetDeviceCaps(FXDC_RENDER_CAPS);
26 m_DeviceClass = m_pDeviceDriver->GetDeviceCaps(FXDC_DEVICE_CLASS);
27 if (!m_pDeviceDriver->GetClipBox(&m_ClipBox)) {
28 m_ClipBox.left = 0;
29 m_ClipBox.top = 0;
30 m_ClipBox.right = m_Width;
31 m_ClipBox.bottom = m_Height;
32 }
33 }
StartRendering()34 FX_BOOL CFX_RenderDevice::StartRendering() {
35 return m_pDeviceDriver->StartRendering();
36 }
EndRendering()37 void CFX_RenderDevice::EndRendering() {
38 m_pDeviceDriver->EndRendering();
39 }
SaveState()40 void CFX_RenderDevice::SaveState() {
41 m_pDeviceDriver->SaveState();
42 }
RestoreState(FX_BOOL bKeepSaved)43 void CFX_RenderDevice::RestoreState(FX_BOOL bKeepSaved) {
44 m_pDeviceDriver->RestoreState(bKeepSaved);
45 UpdateClipBox();
46 }
GetDeviceCaps(int caps_id) const47 int CFX_RenderDevice::GetDeviceCaps(int caps_id) const {
48 return m_pDeviceDriver->GetDeviceCaps(caps_id);
49 }
GetCTM() const50 CFX_Matrix CFX_RenderDevice::GetCTM() const {
51 return m_pDeviceDriver->GetCTM();
52 }
CreateCompatibleBitmap(CFX_DIBitmap * pDIB,int width,int height) const53 FX_BOOL CFX_RenderDevice::CreateCompatibleBitmap(CFX_DIBitmap* pDIB,
54 int width,
55 int height) const {
56 if (m_RenderCaps & FXRC_CMYK_OUTPUT) {
57 return pDIB->Create(width, height, m_RenderCaps & FXRC_ALPHA_OUTPUT
58 ? FXDIB_Cmyka
59 : FXDIB_Cmyk);
60 }
61 if (m_RenderCaps & FXRC_BYTEMASK_OUTPUT) {
62 return pDIB->Create(width, height, FXDIB_8bppMask);
63 }
64 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
65 return pDIB->Create(width, height, m_RenderCaps & FXRC_ALPHA_OUTPUT
66 ? FXDIB_Argb
67 : FXDIB_Rgb32);
68 #else
69 return pDIB->Create(
70 width, height, m_RenderCaps & FXRC_ALPHA_OUTPUT ? FXDIB_Argb : FXDIB_Rgb);
71 #endif
72 }
SetClip_PathFill(const CFX_PathData * pPathData,const CFX_Matrix * pObject2Device,int fill_mode)73 FX_BOOL CFX_RenderDevice::SetClip_PathFill(const CFX_PathData* pPathData,
74 const CFX_Matrix* pObject2Device,
75 int fill_mode) {
76 if (!m_pDeviceDriver->SetClip_PathFill(pPathData, pObject2Device,
77 fill_mode)) {
78 return FALSE;
79 }
80 UpdateClipBox();
81 return TRUE;
82 }
SetClip_PathStroke(const CFX_PathData * pPathData,const CFX_Matrix * pObject2Device,const CFX_GraphStateData * pGraphState)83 FX_BOOL CFX_RenderDevice::SetClip_PathStroke(
84 const CFX_PathData* pPathData,
85 const CFX_Matrix* pObject2Device,
86 const CFX_GraphStateData* pGraphState) {
87 if (!m_pDeviceDriver->SetClip_PathStroke(pPathData, pObject2Device,
88 pGraphState)) {
89 return FALSE;
90 }
91 UpdateClipBox();
92 return TRUE;
93 }
SetClip_Rect(const FX_RECT * pRect)94 FX_BOOL CFX_RenderDevice::SetClip_Rect(const FX_RECT* pRect) {
95 CFX_PathData path;
96 path.AppendRect((FX_FLOAT)(pRect->left), (FX_FLOAT)(pRect->bottom),
97 (FX_FLOAT)(pRect->right), (FX_FLOAT)(pRect->top));
98 if (!SetClip_PathFill(&path, NULL, FXFILL_WINDING)) {
99 return FALSE;
100 }
101 UpdateClipBox();
102 return TRUE;
103 }
UpdateClipBox()104 void CFX_RenderDevice::UpdateClipBox() {
105 if (m_pDeviceDriver->GetClipBox(&m_ClipBox)) {
106 return;
107 }
108 m_ClipBox.left = 0;
109 m_ClipBox.top = 0;
110 m_ClipBox.right = m_Width;
111 m_ClipBox.bottom = m_Height;
112 }
DrawPath(const CFX_PathData * pPathData,const CFX_Matrix * pObject2Device,const CFX_GraphStateData * pGraphState,FX_DWORD fill_color,FX_DWORD stroke_color,int fill_mode,int alpha_flag,void * pIccTransform,int blend_type)113 FX_BOOL CFX_RenderDevice::DrawPath(const CFX_PathData* pPathData,
114 const CFX_Matrix* pObject2Device,
115 const CFX_GraphStateData* pGraphState,
116 FX_DWORD fill_color,
117 FX_DWORD stroke_color,
118 int fill_mode,
119 int alpha_flag,
120 void* pIccTransform,
121 int blend_type) {
122 uint8_t fill_alpha, stroke_alpha;
123 if (FXGETFLAG_COLORTYPE(alpha_flag)) {
124 fill_alpha = FXGETFLAG_ALPHA_FILL(alpha_flag);
125 stroke_alpha = FXGETFLAG_ALPHA_STROKE(alpha_flag);
126 } else {
127 fill_alpha = FXARGB_A(fill_color);
128 stroke_alpha = FXARGB_A(stroke_color);
129 }
130 if ((fill_mode & 3) == 0) {
131 fill_alpha = 0;
132 }
133 if (!pGraphState) {
134 stroke_alpha = 0;
135 }
136 if (stroke_alpha == 0 && pPathData->GetPointCount() == 2) {
137 FX_PATHPOINT* pPoints = pPathData->GetPoints();
138 FX_FLOAT x1, x2, y1, y2;
139 if (pObject2Device) {
140 pObject2Device->Transform(pPoints[0].m_PointX, pPoints[0].m_PointY, x1,
141 y1);
142 pObject2Device->Transform(pPoints[1].m_PointX, pPoints[1].m_PointY, x2,
143 y2);
144 } else {
145 x1 = pPoints[0].m_PointX;
146 y1 = pPoints[0].m_PointY;
147 x2 = pPoints[1].m_PointX;
148 y2 = pPoints[1].m_PointY;
149 }
150 DrawCosmeticLine(x1, y1, x2, y2, fill_color, fill_mode, alpha_flag,
151 pIccTransform, blend_type);
152 return TRUE;
153 }
154 if ((pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) &&
155 stroke_alpha == 0) {
156 CFX_FloatRect rect_f;
157 if (!(fill_mode & FXFILL_RECT_AA) &&
158 pPathData->IsRect(pObject2Device, &rect_f)) {
159 FX_RECT rect_i = rect_f.GetOutterRect();
160 int width = (int)FXSYS_ceil(rect_f.right - rect_f.left);
161 if (width < 1) {
162 width = 1;
163 if (rect_i.left == rect_i.right) {
164 rect_i.right++;
165 }
166 }
167 int height = (int)FXSYS_ceil(rect_f.top - rect_f.bottom);
168 if (height < 1) {
169 height = 1;
170 if (rect_i.bottom == rect_i.top) {
171 rect_i.bottom++;
172 }
173 }
174 if (rect_i.Width() >= width + 1) {
175 if (rect_f.left - (FX_FLOAT)(rect_i.left) >
176 (FX_FLOAT)(rect_i.right) - rect_f.right) {
177 rect_i.left++;
178 } else {
179 rect_i.right--;
180 }
181 }
182 if (rect_i.Height() >= height + 1) {
183 if (rect_f.top - (FX_FLOAT)(rect_i.top) >
184 (FX_FLOAT)(rect_i.bottom) - rect_f.bottom) {
185 rect_i.top++;
186 } else {
187 rect_i.bottom--;
188 }
189 }
190 if (FillRect(&rect_i, fill_color, alpha_flag, pIccTransform,
191 blend_type)) {
192 return TRUE;
193 }
194 }
195 }
196 if ((fill_mode & 3) && stroke_alpha == 0 && !(fill_mode & FX_FILL_STROKE) &&
197 !(fill_mode & FX_FILL_TEXT_MODE)) {
198 CFX_PathData newPath;
199 FX_BOOL bThin = FALSE;
200 if (pPathData->GetZeroAreaPath(newPath, (CFX_Matrix*)pObject2Device, bThin,
201 m_pDeviceDriver->GetDriverType())) {
202 CFX_GraphStateData graphState;
203 graphState.m_LineWidth = 0.0f;
204 FX_DWORD strokecolor = fill_color;
205 if (bThin) {
206 if (FXGETFLAG_COLORTYPE(alpha_flag)) {
207 FXSETFLAG_ALPHA_STROKE(alpha_flag, fill_alpha >> 2);
208 } else {
209 strokecolor =
210 (((fill_alpha >> 2) << 24) | (strokecolor & 0x00ffffff));
211 }
212 }
213 CFX_Matrix* pMatrix = NULL;
214 if (pObject2Device && !pObject2Device->IsIdentity()) {
215 pMatrix = (CFX_Matrix*)pObject2Device;
216 }
217 int smooth_path = FX_ZEROAREA_FILL;
218 if (fill_mode & FXFILL_NOPATHSMOOTH) {
219 smooth_path |= FXFILL_NOPATHSMOOTH;
220 }
221 m_pDeviceDriver->DrawPath(&newPath, pMatrix, &graphState, 0, strokecolor,
222 smooth_path, alpha_flag, pIccTransform,
223 blend_type);
224 }
225 }
226 if ((fill_mode & 3) && fill_alpha && stroke_alpha < 0xff &&
227 (fill_mode & FX_FILL_STROKE)) {
228 if (!(m_RenderCaps & FXRC_GET_BITS)) {
229 return FALSE;
230 }
231 CFX_FloatRect bbox;
232 if (pGraphState) {
233 bbox = pPathData->GetBoundingBox(pGraphState->m_LineWidth,
234 pGraphState->m_MiterLimit);
235 } else {
236 bbox = pPathData->GetBoundingBox();
237 }
238 if (pObject2Device) {
239 bbox.Transform(pObject2Device);
240 }
241 CFX_Matrix ctm = GetCTM();
242 FX_FLOAT fScaleX = FXSYS_fabs(ctm.a);
243 FX_FLOAT fScaleY = FXSYS_fabs(ctm.d);
244 FX_RECT rect = bbox.GetOutterRect();
245 CFX_DIBitmap bitmap, Backdrop;
246 if (!CreateCompatibleBitmap(&bitmap, FXSYS_round(rect.Width() * fScaleX),
247 FXSYS_round(rect.Height() * fScaleY))) {
248 return FALSE;
249 }
250 if (bitmap.HasAlpha()) {
251 bitmap.Clear(0);
252 Backdrop.Copy(&bitmap);
253 } else {
254 if (!m_pDeviceDriver->GetDIBits(&bitmap, rect.left, rect.top, NULL)) {
255 return FALSE;
256 }
257 Backdrop.Copy(&bitmap);
258 }
259 CFX_FxgeDevice bitmap_device;
260 bitmap_device.Attach(&bitmap, 0, FALSE, &Backdrop, TRUE);
261 CFX_Matrix matrix;
262 if (pObject2Device) {
263 matrix = *pObject2Device;
264 }
265 matrix.TranslateI(-rect.left, -rect.top);
266 matrix.Concat(fScaleX, 0, 0, fScaleY, 0, 0);
267 if (!bitmap_device.GetDeviceDriver()->DrawPath(
268 pPathData, &matrix, pGraphState, fill_color, stroke_color,
269 fill_mode, alpha_flag, pIccTransform, blend_type)) {
270 return FALSE;
271 }
272 FX_RECT src_rect(0, 0, FXSYS_round(rect.Width() * fScaleX),
273 FXSYS_round(rect.Height() * fScaleY));
274 return m_pDeviceDriver->SetDIBits(&bitmap, 0, &src_rect, rect.left,
275 rect.top, FXDIB_BLEND_NORMAL);
276 }
277 return m_pDeviceDriver->DrawPath(pPathData, pObject2Device, pGraphState,
278 fill_color, stroke_color, fill_mode,
279 alpha_flag, pIccTransform, blend_type);
280 }
SetPixel(int x,int y,FX_DWORD color,int alpha_flag,void * pIccTransform)281 FX_BOOL CFX_RenderDevice::SetPixel(int x,
282 int y,
283 FX_DWORD color,
284 int alpha_flag,
285 void* pIccTransform) {
286 if (m_pDeviceDriver->SetPixel(x, y, color, alpha_flag, pIccTransform)) {
287 return TRUE;
288 }
289 FX_RECT rect(x, y, x + 1, y + 1);
290 return FillRect(&rect, color, alpha_flag, pIccTransform);
291 }
FillRect(const FX_RECT * pRect,FX_DWORD fill_color,int alpha_flag,void * pIccTransform,int blend_type)292 FX_BOOL CFX_RenderDevice::FillRect(const FX_RECT* pRect,
293 FX_DWORD fill_color,
294 int alpha_flag,
295 void* pIccTransform,
296 int blend_type) {
297 if (m_pDeviceDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransform,
298 blend_type)) {
299 return TRUE;
300 }
301 if (!(m_RenderCaps & FXRC_GET_BITS)) {
302 return FALSE;
303 }
304 CFX_DIBitmap bitmap;
305 if (!CreateCompatibleBitmap(&bitmap, pRect->Width(), pRect->Height())) {
306 return FALSE;
307 }
308 if (!m_pDeviceDriver->GetDIBits(&bitmap, pRect->left, pRect->top)) {
309 return FALSE;
310 }
311 if (!bitmap.CompositeRect(0, 0, pRect->Width(), pRect->Height(), fill_color,
312 alpha_flag, pIccTransform)) {
313 return FALSE;
314 }
315 FX_RECT src_rect(0, 0, pRect->Width(), pRect->Height());
316 m_pDeviceDriver->SetDIBits(&bitmap, 0, &src_rect, pRect->left, pRect->top,
317 FXDIB_BLEND_NORMAL);
318 return TRUE;
319 }
DrawCosmeticLine(FX_FLOAT x1,FX_FLOAT y1,FX_FLOAT x2,FX_FLOAT y2,FX_DWORD color,int fill_mode,int alpha_flag,void * pIccTransform,int blend_type)320 FX_BOOL CFX_RenderDevice::DrawCosmeticLine(FX_FLOAT x1,
321 FX_FLOAT y1,
322 FX_FLOAT x2,
323 FX_FLOAT y2,
324 FX_DWORD color,
325 int fill_mode,
326 int alpha_flag,
327 void* pIccTransform,
328 int blend_type) {
329 if (((m_RenderCaps & FXRC_ALPHA_PATH) &&
330 (FXGETFLAG_COLORTYPE(alpha_flag) &&
331 FXGETFLAG_ALPHA_FILL(alpha_flag) == 0xff)) ||
332 color >= 0xff000000)
333 if (m_pDeviceDriver->DrawCosmeticLine(x1, y1, x2, y2, color, alpha_flag,
334 pIccTransform, blend_type)) {
335 return TRUE;
336 }
337 CFX_GraphStateData graph_state;
338 CFX_PathData path;
339 path.SetPointCount(2);
340 path.SetPoint(0, x1, y1, FXPT_MOVETO);
341 path.SetPoint(1, x2, y2, FXPT_LINETO);
342 return m_pDeviceDriver->DrawPath(&path, NULL, &graph_state, 0, color,
343 fill_mode, alpha_flag, pIccTransform,
344 blend_type);
345 }
GetDIBits(CFX_DIBitmap * pBitmap,int left,int top,void * pIccTransform)346 FX_BOOL CFX_RenderDevice::GetDIBits(CFX_DIBitmap* pBitmap,
347 int left,
348 int top,
349 void* pIccTransform) {
350 if (!(m_RenderCaps & FXRC_GET_BITS)) {
351 return FALSE;
352 }
353 return m_pDeviceDriver->GetDIBits(pBitmap, left, top, pIccTransform);
354 }
GetBackDrop()355 CFX_DIBitmap* CFX_RenderDevice::GetBackDrop() {
356 return m_pDeviceDriver->GetBackDrop();
357 }
SetDIBits(const CFX_DIBSource * pBitmap,int left,int top,int blend_mode,void * pIccTransform)358 FX_BOOL CFX_RenderDevice::SetDIBits(const CFX_DIBSource* pBitmap,
359 int left,
360 int top,
361 int blend_mode,
362 void* pIccTransform) {
363 ASSERT(!pBitmap->IsAlphaMask());
364 CFX_Matrix ctm = GetCTM();
365 FX_FLOAT fScaleX = FXSYS_fabs(ctm.a);
366 FX_FLOAT fScaleY = FXSYS_fabs(ctm.d);
367 FX_RECT dest_rect(left, top,
368 FXSYS_round(left + pBitmap->GetWidth() / fScaleX),
369 FXSYS_round(top + pBitmap->GetHeight() / fScaleY));
370 dest_rect.Intersect(m_ClipBox);
371 if (dest_rect.IsEmpty()) {
372 return TRUE;
373 }
374 FX_RECT src_rect(dest_rect.left - left, dest_rect.top - top,
375 dest_rect.left - left + dest_rect.Width(),
376 dest_rect.top - top + dest_rect.Height());
377 src_rect.left = FXSYS_round(src_rect.left * fScaleX);
378 src_rect.top = FXSYS_round(src_rect.top * fScaleY);
379 src_rect.right = FXSYS_round(src_rect.right * fScaleX);
380 src_rect.bottom = FXSYS_round(src_rect.bottom * fScaleY);
381 if ((blend_mode != FXDIB_BLEND_NORMAL && !(m_RenderCaps & FXRC_BLEND_MODE)) ||
382 (pBitmap->HasAlpha() && !(m_RenderCaps & FXRC_ALPHA_IMAGE))) {
383 if (!(m_RenderCaps & FXRC_GET_BITS)) {
384 return FALSE;
385 }
386 int bg_pixel_width = FXSYS_round(dest_rect.Width() * fScaleX);
387 int bg_pixel_height = FXSYS_round(dest_rect.Height() * fScaleY);
388 CFX_DIBitmap background;
389 if (!background.Create(
390 bg_pixel_width, bg_pixel_height,
391 (m_RenderCaps & FXRC_CMYK_OUTPUT) ? FXDIB_Cmyk : FXDIB_Rgb32)) {
392 return FALSE;
393 }
394 if (!m_pDeviceDriver->GetDIBits(&background, dest_rect.left,
395 dest_rect.top)) {
396 return FALSE;
397 }
398 if (!background.CompositeBitmap(0, 0, bg_pixel_width, bg_pixel_height,
399 pBitmap, src_rect.left, src_rect.top,
400 blend_mode, NULL, FALSE, pIccTransform)) {
401 return FALSE;
402 }
403 FX_RECT src_rect(0, 0, bg_pixel_width, bg_pixel_height);
404 return m_pDeviceDriver->SetDIBits(&background, 0, &src_rect, dest_rect.left,
405 dest_rect.top, FXDIB_BLEND_NORMAL);
406 }
407 return m_pDeviceDriver->SetDIBits(pBitmap, 0, &src_rect, dest_rect.left,
408 dest_rect.top, blend_mode, 0,
409 pIccTransform);
410 }
StretchDIBits(const CFX_DIBSource * pBitmap,int left,int top,int dest_width,int dest_height,FX_DWORD flags,void * pIccTransform,int blend_mode)411 FX_BOOL CFX_RenderDevice::StretchDIBits(const CFX_DIBSource* pBitmap,
412 int left,
413 int top,
414 int dest_width,
415 int dest_height,
416 FX_DWORD flags,
417 void* pIccTransform,
418 int blend_mode) {
419 FX_RECT dest_rect(left, top, left + dest_width, top + dest_height);
420 FX_RECT clip_box = m_ClipBox;
421 clip_box.Intersect(dest_rect);
422 if (clip_box.IsEmpty()) {
423 return TRUE;
424 }
425 return m_pDeviceDriver->StretchDIBits(pBitmap, 0, left, top, dest_width,
426 dest_height, &clip_box, flags, 0,
427 pIccTransform, blend_mode);
428 }
SetBitMask(const CFX_DIBSource * pBitmap,int left,int top,FX_DWORD argb,int alpha_flag,void * pIccTransform)429 FX_BOOL CFX_RenderDevice::SetBitMask(const CFX_DIBSource* pBitmap,
430 int left,
431 int top,
432 FX_DWORD argb,
433 int alpha_flag,
434 void* pIccTransform) {
435 FX_RECT src_rect(0, 0, pBitmap->GetWidth(), pBitmap->GetHeight());
436 return m_pDeviceDriver->SetDIBits(pBitmap, argb, &src_rect, left, top,
437 FXDIB_BLEND_NORMAL, alpha_flag,
438 pIccTransform);
439 }
StretchBitMask(const CFX_DIBSource * pBitmap,int left,int top,int dest_width,int dest_height,FX_DWORD argb,FX_DWORD flags,int alpha_flag,void * pIccTransform)440 FX_BOOL CFX_RenderDevice::StretchBitMask(const CFX_DIBSource* pBitmap,
441 int left,
442 int top,
443 int dest_width,
444 int dest_height,
445 FX_DWORD argb,
446 FX_DWORD flags,
447 int alpha_flag,
448 void* pIccTransform) {
449 FX_RECT dest_rect(left, top, left + dest_width, top + dest_height);
450 FX_RECT clip_box = m_ClipBox;
451 clip_box.Intersect(dest_rect);
452 return m_pDeviceDriver->StretchDIBits(pBitmap, argb, left, top, dest_width,
453 dest_height, &clip_box, flags,
454 alpha_flag, pIccTransform);
455 }
StartDIBits(const CFX_DIBSource * pBitmap,int bitmap_alpha,FX_DWORD argb,const CFX_Matrix * pMatrix,FX_DWORD flags,void * & handle,int alpha_flag,void * pIccTransform,int blend_mode)456 FX_BOOL CFX_RenderDevice::StartDIBits(const CFX_DIBSource* pBitmap,
457 int bitmap_alpha,
458 FX_DWORD argb,
459 const CFX_Matrix* pMatrix,
460 FX_DWORD flags,
461 void*& handle,
462 int alpha_flag,
463 void* pIccTransform,
464 int blend_mode) {
465 return m_pDeviceDriver->StartDIBits(pBitmap, bitmap_alpha, argb, pMatrix,
466 flags, handle, alpha_flag, pIccTransform,
467 blend_mode);
468 }
ContinueDIBits(void * handle,IFX_Pause * pPause)469 FX_BOOL CFX_RenderDevice::ContinueDIBits(void* handle, IFX_Pause* pPause) {
470 return m_pDeviceDriver->ContinueDIBits(handle, pPause);
471 }
CancelDIBits(void * handle)472 void CFX_RenderDevice::CancelDIBits(void* handle) {
473 m_pDeviceDriver->CancelDIBits(handle);
474 }
475