| OLD | NEW |
|---|
| (Empty) |
| 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 #include "../../../include/fxge/fx_ge.h" | |
| 6 //#define _SKIA_SUPPORT_ | |
| 7 #if defined(_SKIA_SUPPORT_) | |
| 8 #include "../../../include/fxcodec/fx_codec.h" | |
| 9 | |
| 10 | |
| 11 //#define _FOXIT_DEBUG_ | |
| 12 //#define _FOXIT_BENCHMARK_ | |
| 13 | |
| 14 extern "C" { | |
| 15 extern void FX_OUTPUT_LOG_FUNC(const char*, ...); | |
| 16 extern int FX_GET_TICK_FUNC(); | |
| 17 }; | |
| 18 | |
| 19 #ifdef _FOXIT_DEBUG_ | |
| 20 #define FOXIT_DEBUG1(msg) FX_OUTPUT_LOG_FUNC(msg) | |
| 21 #define FOXIT_DEBUG2(msg,para) FX_OUTPUT_LOG_FUNC(msg,para) | |
| 22 #define FOXIT_DEBUG3(msg,para1,para2) FX_OUTPUT_LOG_FUNC(msg,para1,para2) | |
| 23 #define FOXIT_DEBUG4(msg,para1,para2,para3) FX_OUTPUT_LOG_FUNC(msg,para1,para2,p
ara3) | |
| 24 #define FOXIT_DEBUG5(msg,para1,para2,para3,param4) FX_OUTPUT_LOG_FUNC(msg,para1,
para2,para3,param4) | |
| 25 #else | |
| 26 #define FOXIT_DEBUG1(msg) | |
| 27 #define FOXIT_DEBUG2(msg,para) | |
| 28 #define FOXIT_DEBUG3(msg,para1,para2) | |
| 29 #define FOXIT_DEBUG4(msg,para1,para2,para3) | |
| 30 #define FOXIT_DEBUG5(msg,para1,para2,para3,param4) | |
| 31 #endif | |
| 32 | |
| 33 #include "SkDashPathEffect.h" | |
| 34 #include "SkTLazy.h" | |
| 35 #include "SkScan.h" | |
| 36 #include "SkRasterClip.h" | |
| 37 #include "SkStroke.h" | |
| 38 | |
| 39 | |
| 40 #include "fx_skia_blitter_new.h" | |
| 41 #include "../agg/fx_agg_driver.h" | |
| 42 #include "fx_skia_device.h" | |
| 43 /// Run-length-encoded supersampling antialiased blitter. | |
| 44 class SuperBlitter_skia | |
| 45 { | |
| 46 public: | |
| 47 static void DrawPath(const SkPath& srcPath, SkBlitter* blitter, const S
kRasterClip& rect, const SkPaint& origPaint); | |
| 48 }; | |
| 49 FX_BOOL FxSkDrawTreatAsHairline(const SkPaint& paint, SkScalar* coverage) { | |
| 50 if (SkPaint::kStroke_Style != paint.getStyle()) | |
| 51 return FALSE; | |
| 52 FXSYS_assert(coverage); | |
| 53 SkScalar strokeWidth = paint.getStrokeWidth(); | |
| 54 if (0 == strokeWidth) { | |
| 55 *coverage = SK_Scalar1; | |
| 56 return TRUE; | |
| 57 } | |
| 58 // if we get here, we need to try to fake a thick-stroke with a modulate
d | |
| 59 // hairline | |
| 60 if (!paint.isAntiAlias()) | |
| 61 return FALSE; | |
| 62 if (strokeWidth <= SK_Scalar1) { | |
| 63 *coverage = strokeWidth; | |
| 64 return TRUE; | |
| 65 } | |
| 66 return FALSE; | |
| 67 } | |
| 68 | |
| 69 void SuperBlitter_skia::DrawPath(const SkPath& srcPath, SkBlitter* blitter, cons
t SkRasterClip& rect, const SkPaint& origPaint) | |
| 70 { | |
| 71 SkPath* pathPtr = (SkPath*)&srcPath; | |
| 72 bool doFill = true; | |
| 73 SkPath tmpPath; | |
| 74 SkTCopyOnFirstWrite<SkPaint> paint(origPaint); | |
| 75 { | |
| 76 SkScalar coverage; | |
| 77 if (FxSkDrawTreatAsHairline(origPaint, &coverage)) { | |
| 78 if (SK_Scalar1 == coverage) { | |
| 79 paint.writable()->setStrokeWidth(0); | |
| 80 } else if (1) {//xfermodeSupportsCoverageAsAlpha(xfer),
we not use blend mode here, xfer aways NULL. | |
| 81 U8CPU newAlpha; | |
| 82 // this is the old technique, which we preserve
for now so | |
| 83 // we don't change previous results (testing) | |
| 84 // the new way seems fine, its just (a tiny bit)
different | |
| 85 int scale = (int)SkScalarMul(coverage, 256); | |
| 86 newAlpha = origPaint.getAlpha() * scale >> 8; | |
| 87 SkPaint* writablePaint = paint.writable(); | |
| 88 writablePaint->setStrokeWidth(0); | |
| 89 writablePaint->setAlpha(newAlpha); | |
| 90 } | |
| 91 } | |
| 92 } | |
| 93 if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style)
{ | |
| 94 SkIRect devBounds = rect.getBounds(); | |
| 95 // outset to have slop for antialasing and hairlines | |
| 96 devBounds.outset(1, 1); | |
| 97 SkRect cullRect = SkRect::Make(devBounds); | |
| 98 doFill = paint->getFillPath(*pathPtr, &tmpPath, &cullRect); | |
| 99 pathPtr = &tmpPath; | |
| 100 } | |
| 101 // avoid possibly allocating a new path in transform if we can | |
| 102 SkPath* devPathPtr = pathPtr; | |
| 103 void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*); | |
| 104 if (doFill) { | |
| 105 if (paint->isAntiAlias()) { | |
| 106 proc = SkScan::AntiFillPath; | |
| 107 } else { | |
| 108 proc = SkScan::FillPath; | |
| 109 } | |
| 110 } else { // hairline | |
| 111 if (paint->isAntiAlias()) { | |
| 112 proc = SkScan::AntiHairPath; | |
| 113 } else { | |
| 114 proc = SkScan::HairPath; | |
| 115 } | |
| 116 } | |
| 117 proc(*devPathPtr, rect, blitter); | |
| 118 } | |
| 119 | |
| 120 class CSkia_PathData : public CFX_Object | |
| 121 { | |
| 122 public: | |
| 123 CSkia_PathData() {} | |
| 124 ~CSkia_PathData() {} | |
| 125 SkPath m_PathData; | |
| 126 | |
| 127 void BuildPath(const CFX_PathData* pPathData, const C
FX_AffineMatrix* pObject2Device); | |
| 128 }; | |
| 129 | |
| 130 void CSkia_PathData::BuildPath(const CFX_PathData* pPathData, const CFX_AffineMa
trix* pObject2Device) | |
| 131 { | |
| 132 const CFX_PathData* pFPath = pPathData; | |
| 133 int nPoints = pFPath->GetPointCount(); | |
| 134 FX_PATHPOINT* pPoints = pFPath->GetPoints(); | |
| 135 for (int i = 0; i < nPoints; i ++) { | |
| 136 FX_FIXFLOAT x = pPoints[i].m_PointX, y = pPoints[i].m_PointY; | |
| 137 if (pObject2Device) pObject2Device->Transform(x, y); | |
| 138 int point_type = pPoints[i].m_Flag & FXPT_TYPE; | |
| 139 if (point_type == FXPT_MOVETO) { | |
| 140 m_PathData.moveTo(x, y); | |
| 141 } else if (point_type == FXPT_LINETO) { | |
| 142 if (pPoints[i-1].m_Flag == FXPT_MOVETO && (i == nPoints-
1 || pPoints[i+1].m_Flag == FXPT_MOVETO) && | |
| 143 FXSYS_abs(pPoints[i].m_PointX - pPoints[
i-1].m_PointX) < 0.4f && FXSYS_abs(pPoints[i].m_PointY - pPoints[i-1].m_PointY)<
0.4f) | |
| 144 // PDF line includes the destination point, unli
ke Windows line. | |
| 145 // We received some PDF which actually draws zer
o length lines. TESTDOC: summer cha show.pdf | |
| 146 // Therefore, we have to extend the line by 0.4
pixel here. | |
| 147 // But only for standalone segment. TESTDOC: bug
#1434 - maze.pdf; TESTDOC: bug#1508 di704P_QIG_111.pdf | |
| 148 x += 0.4; | |
| 149 // TODO: we should actually tell skia vertex generator t
o process zero length stroked line | |
| 150 // (only butts are drawn) | |
| 151 m_PathData.lineTo(x, y); | |
| 152 } else if (point_type == FXPT_BEZIERTO) { | |
| 153 FX_FIXFLOAT x2 = pPoints[i+1].m_PointX, y2 = pPoints[i+1
].m_PointY; | |
| 154 FX_FIXFLOAT x3 = pPoints[i+2].m_PointX, y3 = pPoints[i+2
].m_PointY; | |
| 155 if (pObject2Device){ | |
| 156 pObject2Device->Transform(x2, y2); | |
| 157 pObject2Device->Transform(x3, y3); | |
| 158 } | |
| 159 m_PathData.cubicTo(x, y, x2, y2, x3, y3); | |
| 160 i += 2; | |
| 161 } | |
| 162 if (pPoints[i].m_Flag & FXPT_CLOSEFIGURE) m_PathData.close(); | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 // convert a stroking path to scanlines | |
| 167 static void SkRasterizeStroke(SkPaint& spaint, SkPath* dstPathData, SkPath& path
_data, | |
| 168 const CFX_AffineMatrix* pObject2Device, | |
| 169 const CFX_GraphStateData* pGraphState,
FX_FIXFLOAT scale = FIX8_ONE, | |
| 170 FX_BOOL bStrokeAdjust = FALSE, FX_BOOL
bTextMode = FALSE) | |
| 171 { | |
| 172 SkPaint::Cap cap; | |
| 173 switch (pGraphState->m_LineCap) { | |
| 174 case CFX_GraphStateData::LineCapRound: | |
| 175 cap = SkPaint::kRound_Cap; | |
| 176 break; | |
| 177 case CFX_GraphStateData::LineCapSquare: | |
| 178 cap = SkPaint::kSquare_Cap; | |
| 179 break; | |
| 180 default: | |
| 181 cap = SkPaint::kButt_Cap; | |
| 182 break; | |
| 183 } | |
| 184 SkPaint::Join join; | |
| 185 switch (pGraphState->m_LineJoin) { | |
| 186 case CFX_GraphStateData::LineJoinRound: | |
| 187 join = SkPaint::kRound_Join; | |
| 188 break; | |
| 189 case CFX_GraphStateData::LineJoinBevel: | |
| 190 join = SkPaint::kBevel_Join; | |
| 191 break; | |
| 192 default: | |
| 193 join = SkPaint::kMiter_Join; | |
| 194 break; | |
| 195 } | |
| 196 FX_FIXFLOAT width = pGraphState->m_LineWidth*scale; | |
| 197 FX_FIXFLOAT unit = fix32_to_8(fixdiv_8_8_to_32(FIX8_ONE, (pObject2Device
->GetXUnit() + pObject2Device->GetYUnit()) / 2)); | |
| 198 if (width <= unit) width = unit; | |
| 199 | |
| 200 if (pGraphState->m_DashArray == NULL) { | |
| 201 SkStroke stroker; | |
| 202 stroker.setCap(cap); | |
| 203 stroker.setJoin(join); | |
| 204 stroker.setMiterLimit(pGraphState->m_MiterLimit); | |
| 205 stroker.setWidth(width); | |
| 206 stroker.setDoFill(FALSE); | |
| 207 stroker.strokePath(path_data, dstPathData); | |
| 208 SkMatrix smatrix; | |
| 209 smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Dev
ice->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1); | |
| 210 dstPathData->transform(smatrix); | |
| 211 } else { | |
| 212 int count = (pGraphState->m_DashCount+1)/2; | |
| 213 SkScalar* intervals = FX_Alloc(SkScalar, count* sizeof (SkScalar
)); | |
| 214 // Set dash pattern | |
| 215 for (int i = 0; i < count; i ++) { | |
| 216 FX_FIXFLOAT on = pGraphState->m_DashArray[i*2]; | |
| 217 if (on <= 0.000001f) on = FIX8_ONE/10; | |
| 218 FX_FIXFLOAT off = i*2+1 == pGraphState->m_DashCount ? on
: | |
| 219 pGraphState->m_DashArray[i*2+1]; | |
| 220 if (off < 0) off = 0; | |
| 221 intervals[i*2]=on*scale; | |
| 222 intervals[i*2+1]=off*scale; | |
| 223 } | |
| 224 SkDashPathEffect* pEffect = new SkDashPathEffect(intervals,count
*2, pGraphState->m_DashPhase*scale); | |
| 225 spaint.setPathEffect(pEffect)->unref(); | |
| 226 spaint.setStrokeWidth(width); | |
| 227 spaint.setStrokeMiter(pGraphState->m_MiterLimit); | |
| 228 spaint.setStrokeCap(cap); | |
| 229 spaint.setStrokeJoin(join); | |
| 230 spaint.getFillPath(path_data, dstPathData); | |
| 231 SkMatrix smatrix; | |
| 232 smatrix.setAll(pObject2Device->a, pObject2Device->c, pObject2Dev
ice->e, pObject2Device->b, pObject2Device->d, pObject2Device->f, 0, 0, 1); | |
| 233 dstPathData->transform(smatrix); | |
| 234 FX_Free(intervals); | |
| 235 } | |
| 236 } | |
| 237 | |
| 238 CFX_SkiaDeviceDriver::CFX_SkiaDeviceDriver(CFX_DIBitmap* pBitmap, int dither_bit
s, FX_BOOL bRgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout) | |
| 239 { | |
| 240 m_pAggDriver = FX_NEW CFX_AggDeviceDriver(pBitmap, dither_bits, bRgbByte
Order, pOriDevice, bGroupKnockout); | |
| 241 } | |
| 242 CFX_SkiaDeviceDriver::~CFX_SkiaDeviceDriver() | |
| 243 { | |
| 244 if (m_pAggDriver) delete m_pAggDriver; | |
| 245 } | |
| 246 FX_BOOL CFX_SkiaDeviceDriver::DrawDeviceText(int nChars, const FXTEXT_CHARPOS* p
CharPos, CFX_Font* pFont, | |
| 247 CFX_FontCache* pCache, const CFX_AffineMatrix* pObject2Device, F
X_FIXFLOAT font_size, FX_DWORD color, | |
| 248 int alpha_flag, void* pIccTransform) | |
| 249 { | |
| 250 return m_pAggDriver->DrawDeviceText(nChars, pCharPos, pFont,pCache, pObj
ect2Device, font_size, color, | |
| 251 alpha_flag, pIccTransform); | |
| 252 } | |
| 253 int CFX_SkiaDeviceDriver::GetDeviceCaps(int caps_id) | |
| 254 { | |
| 255 return m_pAggDriver->GetDeviceCaps(caps_id); | |
| 256 } | |
| 257 void CFX_SkiaDeviceDriver::SaveState() | |
| 258 { | |
| 259 m_pAggDriver->SaveState(); | |
| 260 } | |
| 261 | |
| 262 void CFX_SkiaDeviceDriver::RestoreState(FX_BOOL bKeepSaved) | |
| 263 { | |
| 264 m_pAggDriver->RestoreState(bKeepSaved); | |
| 265 } | |
| 266 void CFX_SkiaDeviceDriver::SetClipMask(rasterizer_scanline_aa& rasterizer) | |
| 267 { | |
| 268 m_pAggDriver->SetClipMask(rasterizer); | |
| 269 } | |
| 270 void CFX_SkiaDeviceDriver::SetClipMask(SkPath& skPath, SkPaint* spaint) | |
| 271 { | |
| 272 SkIRect clip_box; | |
| 273 clip_box.set(0, 0, fix0_to_8(GetDeviceCaps(FXDC_PIXEL_WIDTH)), fix0_to_8
(GetDeviceCaps(FXDC_PIXEL_HEIGHT))); | |
| 274 clip_box.intersect(m_pAggDriver->m_pClipRgn->GetBox().left, m_pAggDriver
->m_pClipRgn->GetBox().top, | |
| 275 m_pAggDriver->m_pClipRgn->GetBox().right, m_pAggDriver->m_pClipR
gn->GetBox().bottom); | |
| 276 | |
| 277 SkPath* pathPtr = &skPath; | |
| 278 | |
| 279 SkRect path_rect = skPath.getBounds(); | |
| 280 | |
| 281 clip_box.intersect(FXSYS_floor(path_rect.fLeft), FXSYS_floor(path_rect.f
Top), FXSYS_floor(path_rect.fRight)+1, FXSYS_floor(path_rect.fBottom)+1); | |
| 282 CFX_DIBitmapRef mask; | |
| 283 CFX_DIBitmap* pThisLayer = mask.New(); | |
| 284 pThisLayer->Create(clip_box.width(), clip_box.height(), FXDIB_8bppMask); | |
| 285 pThisLayer->Clear(0); | |
| 286 | |
| 287 CFX_SkiaA8Renderer render; | |
| 288 render.Init(pThisLayer, clip_box.fLeft, clip_box.fTop); | |
| 289 | |
| 290 SkRasterClip rasterClip(clip_box); | |
| 291 SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, *sp
aint); | |
| 292 | |
| 293 // Finally, we have got the mask that we need, intersect with current cl
ip region | |
| 294 m_pAggDriver->m_pClipRgn->IntersectMaskF(clip_box.fLeft, clip_box.fTop,
mask); | |
| 295 | |
| 296 } | |
| 297 FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
// path info | |
| 298 const CFX_AffineMatrix* pObject2
Device, // optional transformation | |
| 299 int fill_mode // fill mode, WI
NDING or ALTERNATE | |
| 300 ) | |
| 301 { | |
| 302 if (m_pAggDriver->m_pClipRgn == NULL) | |
| 303 m_pAggDriver->m_pClipRgn = FX_NEW CFX_ClipRgn(GetDeviceCaps(FXDC
_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT)); | |
| 304 | |
| 305 if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4)
{ | |
| 306 CFX_FloatRect rectf; | |
| 307 if (pPathData->IsRect(pObject2Device, &rectf)) { | |
| 308 rectf.Intersect(CFX_FloatRect(0, 0, (FX_FIXFLOAT)GetDevi
ceCaps(FXDC_PIXEL_WIDTH), (FX_FIXFLOAT)GetDeviceCaps(FXDC_PIXEL_HEIGHT))); | |
| 309 FX_RECT rect = rectf.GetOutterRect(); | |
| 310 m_pAggDriver->m_pClipRgn->IntersectRect(rect); | |
| 311 return TRUE; | |
| 312 } | |
| 313 } | |
| 314 CSkia_PathData path_data; | |
| 315 path_data.BuildPath(pPathData, pObject2Device); | |
| 316 path_data.m_PathData.close(); | |
| 317 path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING? SkPath
::kWinding_FillType:SkPath::kEvenOdd_FillType); | |
| 318 | |
| 319 SkPaint spaint; | |
| 320 spaint.setColor(0xffffffff); | |
| 321 spaint.setAntiAlias(TRUE); | |
| 322 spaint.setStyle(SkPaint::kFill_Style); | |
| 323 | |
| 324 SetClipMask(path_data.m_PathData, &spaint); | |
| 325 | |
| 326 return TRUE; | |
| 327 } | |
| 328 | |
| 329 FX_BOOL CFX_SkiaDeviceDriver::SetClip_PathStroke(const CFX_PathData* pPathData,
// path info | |
| 330 const CFX_AffineMatrix* pObject2
Device, // optional transformation | |
| 331 const CFX_GraphStateData* pGraph
State // graphic state, for pen attributes | |
| 332 ) | |
| 333 { | |
| 334 if (m_pAggDriver->m_pClipRgn == NULL) | |
| 335 m_pAggDriver->m_pClipRgn = FX_NEW CFX_ClipRgn(GetDeviceCaps(FXDC
_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL_HEIGHT)); | |
| 336 | |
| 337 // build path data | |
| 338 CSkia_PathData path_data; | |
| 339 path_data.BuildPath(pPathData, NULL); | |
| 340 path_data.m_PathData.setFillType(SkPath::kWinding_FillType); | |
| 341 | |
| 342 SkPaint spaint; | |
| 343 spaint.setColor(0xffffffff); | |
| 344 spaint.setStyle(SkPaint::kStroke_Style); | |
| 345 spaint.setAntiAlias(TRUE); | |
| 346 | |
| 347 SkPath dst_path; | |
| 348 SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, pObject2Devic
e, pGraphState, 1, FALSE, 0); | |
| 349 spaint.setStyle(SkPaint::kFill_Style); | |
| 350 SetClipMask(dst_path, &spaint); | |
| 351 | |
| 352 return TRUE; | |
| 353 } | |
| 354 FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizer(rasterizer_scanline_aa& rasterize
r, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKnockout, | |
| 355
int alpha_flag, void* pIccTransform) | |
| 356 { | |
| 357 return m_pAggDriver->RenderRasterizer(rasterizer, color, bFullCover, bGr
oupKnockout,alpha_flag, pIccTransform); | |
| 358 } | |
| 359 FX_BOOL CFX_SkiaDeviceDriver::RenderRasterizerSkia(SkPath& skPath, const SkPaint
& origPaint, SkIRect& rect, FX_DWORD color, FX_BOOL bFullCover, FX_BOOL bGroupKn
ockout, | |
| 360 int alpha_flag, void* pI
ccTransform, FX_BOOL bFill) | |
| 361 { | |
| 362 CFX_DIBitmap* pt = bGroupKnockout?m_pAggDriver->GetBackDrop():NULL; | |
| 363 CFX_SkiaRenderer render; | |
| 364 if (!render.Init(m_pAggDriver->m_pBitmap, pt, m_pAggDriver->m_pClipRgn,
color, bFullCover, m_pAggDriver->m_bRgbByteOrder, alpha_flag, pIccTransform)) | |
| 365 return FALSE; | |
| 366 | |
| 367 SkRasterClip rasterClip(rect); | |
| 368 SuperBlitter_skia::DrawPath(skPath, (SkBlitter*)&render, rasterClip, or
igPaint); | |
| 369 | |
| 370 return TRUE; | |
| 371 | |
| 372 } | |
| 373 | |
| 374 FX_BOOL CFX_SkiaDeviceDriver::DrawPath(const CFX_PathData* pPathData, // path
info | |
| 375 const CFX_AffineMatrix* pObject2
Device, // optional transformation | |
| 376 const CFX_GraphStateData* pGraph
State, // graphic state, for pen attributes | |
| 377 FX_DWORD fill_color,
// fill color | |
| 378 FX_DWORD stroke_color,
// stroke color | |
| 379 int fill_mode,
// fill mode, WINDING or ALTERNATE. 0 for not filled | |
| 380 int alpha_flag, | |
| 381 void* pIccTransform | |
| 382 ) | |
| 383 { | |
| 384 if (GetBuffer() == NULL) return TRUE; | |
| 385 FOXIT_DEBUG1("CFX_SkiaDeviceDriver::DrawPath: entering"); | |
| 386 SkIRect rect; | |
| 387 rect.set(0, 0, GetDeviceCaps(FXDC_PIXEL_WIDTH), GetDeviceCaps(FXDC_PIXEL
_HEIGHT)); | |
| 388 if ((fill_mode & 3) && fill_color) { | |
| 389 // We have to transform before building path data, otherwise we'
ll have flatting problem | |
| 390 // when we enlarge a small path (flatten before transformed) | |
| 391 // TESTDOC: Bug #5115 - DS_S1Dimpact_lr.pdf | |
| 392 // build path data | |
| 393 CSkia_PathData path_data; | |
| 394 path_data.BuildPath(pPathData, pObject2Device); | |
| 395 //path_data.m_PathData.close(); | |
| 396 path_data.m_PathData.setFillType((fill_mode&3) == FXFILL_WINDING
? SkPath::kWinding_FillType:SkPath::kEvenOdd_FillType); | |
| 397 | |
| 398 SkPaint spaint; | |
| 399 spaint.setAntiAlias(TRUE); | |
| 400 spaint.setStyle(SkPaint::kFill_Style); | |
| 401 spaint.setColor(fill_color); | |
| 402 if (!RenderRasterizerSkia(path_data.m_PathData, spaint, rect, fi
ll_color, fill_mode & FXFILL_FULLCOVER, FALSE, alpha_flag, pIccTransform)) | |
| 403 return FALSE; | |
| 404 } | |
| 405 | |
| 406 int stroke_alpha = FXGETFLAG_COLORTYPE(alpha_flag) ? FXGETFLAG_ALPHA_STR
OKE(alpha_flag) : FXARGB_A(stroke_color); | |
| 407 | |
| 408 if (pGraphState && stroke_alpha) { | |
| 409 // We split the matrix into two parts: first part doing the scal
ing, so we won't have the | |
| 410 // flatness problem, second part doing the transformation, so we
don't have stroking geo problem. | |
| 411 // TESTDOC: Bug #5253 - test[1].pdf | |
| 412 CFX_AffineMatrix matrix1, matrix2; | |
| 413 if (pObject2Device) { | |
| 414 matrix1.a = FXSYS_fabs(pObject2Device->a) > FXSYS_fabs(p
Object2Device->b) ? | |
| 415 FXSYS_fabs(pObject2Device->a) : FXSYS_fa
bs(pObject2Device->b); | |
| 416 matrix1.d = matrix1.a;//FXSYS_fabs(pObject2Device->c) >
FXSYS_fabs(pObject2Device->d) ? | |
| 417 //pObject2Device->c : pObject2Device->d; | |
| 418 matrix2.Set(pObject2Device->a/matrix1.a, pObject2Device-
>b/matrix1.a, | |
| 419 pObject2Device->c/matrix1.d, pObject2Dev
ice->d/matrix1.d, | |
| 420 pObject2Device->e, pObject2Device->f); | |
| 421 } | |
| 422 // build path data | |
| 423 CSkia_PathData path_data; | |
| 424 path_data.BuildPath(pPathData, &matrix1); | |
| 425 path_data.m_PathData.setFillType(SkPath::kWinding_FillType); | |
| 426 | |
| 427 SkPaint spaint; | |
| 428 spaint.setColor(stroke_color); | |
| 429 spaint.setStyle(SkPaint::kStroke_Style); | |
| 430 spaint.setAntiAlias(TRUE); | |
| 431 SkPath dst_path; | |
| 432 SkRasterizeStroke(spaint, &dst_path, path_data.m_PathData, &matr
ix2, pGraphState, matrix1.a, FALSE, 0); | |
| 433 spaint.setStyle(SkPaint::kFill_Style); | |
| 434 int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag)<<8 | FXGETFLAG_A
LPHA_STROKE(alpha_flag); | |
| 435 | |
| 436 if (!RenderRasterizerSkia(dst_path, spaint, rect, stroke_color,
fill_mode & FXFILL_FULLCOVER, FALSE, fill_flag, pIccTransform, FALSE)) | |
| 437 return FALSE; | |
| 438 | |
| 439 } | |
| 440 | |
| 441 return TRUE; | |
| 442 } | |
| 443 | |
| 444 FX_BOOL CFX_SkiaDeviceDriver::SetPixel(int x, int y, FX_DWORD color, | |
| 445 int alpha_flag, void* pIccTransf
orm) | |
| 446 { | |
| 447 return m_pAggDriver->SetPixel(x, y, color, alpha_flag, pIccTransform); | |
| 448 } | |
| 449 | |
| 450 FX_BOOL CFX_SkiaDeviceDriver::FillRect(const FX_RECT* pRect, FX_DWORD fill_color
, int alpha_flag, void* pIccTransform) | |
| 451 { | |
| 452 return m_pAggDriver->FillRect(pRect, fill_color, alpha_flag, pIccTransfo
rm); | |
| 453 } | |
| 454 | |
| 455 FX_BOOL CFX_SkiaDeviceDriver::GetClipBox(FX_RECT* pRect) | |
| 456 { | |
| 457 return m_pAggDriver->GetClipBox(pRect); | |
| 458 } | |
| 459 | |
| 460 FX_BOOL CFX_SkiaDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap, int left, int top
, void* pIccTransform, FX_BOOL bDEdge) | |
| 461 { | |
| 462 return m_pAggDriver->GetDIBits(pBitmap, left, top, pIccTransform, bDEdge
); | |
| 463 } | |
| 464 | |
| 465 FX_BOOL CFX_SkiaDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap, FX_DWORD a
rgb, const FX_RECT* pSrcRect, int left, int top, int blend_type, | |
| 466 int a
lpha_flag, void* pIccTransform) | |
| 467 { | |
| 468 return m_pAggDriver->SetDIBits(pBitmap, argb, pSrcRect, left, top, blend
_type, alpha_flag, pIccTransform); | |
| 469 } | |
| 470 | |
| 471 FX_BOOL CFX_SkiaDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource, FX_DWO
RD argb, int dest_left, int dest_top, | |
| 472 int dest_width, int dest
_height, const FX_RECT* pClipRect, FX_DWORD flags, | |
| 473 int alpha_flag, void* pI
ccTransform) | |
| 474 { | |
| 475 return m_pAggDriver->StretchDIBits(pSource, argb, dest_left, dest_top, | |
| 476 dest_width, dest_height,
pClipRect, flags, | |
| 477 alpha_flag, pIccTransfor
m); | |
| 478 } | |
| 479 | |
| 480 FX_BOOL CFX_SkiaDeviceDriver::StartDIBits(const CFX_DIBSource* pSource, int bitm
ap_alpha, FX_DWORD argb, | |
| 481 const CFX_AffineMatrix* pMatrix,
FX_DWORD render_flags, FX_LPVOID& handle, | |
| 482 int alpha_flag, void* pIccTransf
orm) | |
| 483 { | |
| 484 return m_pAggDriver->StartDIBits(pSource, bitmap_alpha, argb, | |
| 485 pMatrix, render_flags, handle, a
lpha_flag, pIccTransform); | |
| 486 } | |
| 487 | |
| 488 FX_BOOL CFX_SkiaDeviceDriver::ContinueDIBits(FX_LPVOID pHandle, IFX_Pause* pPaus
e) | |
| 489 { | |
| 490 return m_pAggDriver->ContinueDIBits(pHandle, pPause); | |
| 491 } | |
| 492 | |
| 493 void CFX_SkiaDeviceDriver::CancelDIBits(FX_LPVOID pHandle) | |
| 494 { | |
| 495 m_pAggDriver->CancelDIBits(pHandle); | |
| 496 } | |
| 497 | |
| 498 CFX_SkiaDevice::CFX_SkiaDevice() | |
| 499 { | |
| 500 m_bOwnedBitmap = FALSE; | |
| 501 } | |
| 502 | |
| 503 FX_BOOL CFX_SkiaDevice::Attach(CFX_DIBitmap* pBitmap, int dither_bits, FX_BOOL b
RgbByteOrder, CFX_DIBitmap* pOriDevice, FX_BOOL bGroupKnockout) | |
| 504 { | |
| 505 if (pBitmap == NULL) | |
| 506 return FALSE; | |
| 507 SetBitmap(pBitmap); | |
| 508 CFX_SkiaDeviceDriver* pDriver = FX_NEW CFX_SkiaDeviceDriver(pBitmap, dit
her_bits, bRgbByteOrder, pOriDevice, bGroupKnockout); | |
| 509 SetDeviceDriver(pDriver); | |
| 510 return TRUE; | |
| 511 } | |
| 512 | |
| 513 FX_BOOL CFX_SkiaDevice::Create(int width, int height, FXDIB_Format format, int d
ither_bits, CFX_DIBitmap* pOriDevice) | |
| 514 { | |
| 515 m_bOwnedBitmap = TRUE; | |
| 516 CFX_DIBitmap* pBitmap = FX_NEW CFX_DIBitmap; | |
| 517 if (!pBitmap->Create(width, height, format)) { | |
| 518 delete pBitmap; | |
| 519 return FALSE; | |
| 520 } | |
| 521 SetBitmap(pBitmap); | |
| 522 CFX_SkiaDeviceDriver* pDriver = FX_NEW CFX_SkiaDeviceDriver(pBitmap, di
ther_bits, FALSE, pOriDevice, FALSE); | |
| 523 SetDeviceDriver(pDriver); | |
| 524 return TRUE; | |
| 525 } | |
| 526 CFX_SkiaDevice::~CFX_SkiaDevice() | |
| 527 { | |
| 528 if (m_bOwnedBitmap && GetBitmap()) delete GetBitmap(); | |
| 529 } | |
| 530 | |
| 531 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 402463002:
Replace agg with skia (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master