1 /*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #define __STDC_LIMIT_MACROS
9
10 #include "SkArenaAlloc.h"
11 #include "SkAutoBlitterChoose.h"
12 #include "SkBlendModePriv.h"
13 #include "SkBlitter.h"
14 #include "SkCanvas.h"
15 #include "SkColorPriv.h"
16 #include "SkDevice.h"
17 #include "SkDeviceLooper.h"
18 #include "SkDraw.h"
19 #include "SkDrawProcs.h"
20 #include "SkFindAndPlaceGlyph.h"
21 #include "SkMaskFilter.h"
22 #include "SkMatrix.h"
23 #include "SkMatrixUtils.h"
24 #include "SkPaint.h"
25 #include "SkPathEffect.h"
26 #include "SkRasterClip.h"
27 #include "SkRasterizer.h"
28 #include "SkRRect.h"
29 #include "SkScan.h"
30 #include "SkShader.h"
31 #include "SkString.h"
32 #include "SkStroke.h"
33 #include "SkStrokeRec.h"
34 #include "SkTemplates.h"
35 #include "SkTextMapStateProc.h"
36 #include "SkTLazy.h"
37 #include "SkUtils.h"
38
make_paint_with_image(const SkPaint & origPaint,const SkBitmap & bitmap,SkMatrix * matrix=nullptr)39 static SkPaint make_paint_with_image(
40 const SkPaint& origPaint, const SkBitmap& bitmap, SkMatrix* matrix = nullptr) {
41 SkPaint paint(origPaint);
42 paint.setShader(SkMakeBitmapShader(bitmap, SkShader::kClamp_TileMode,
43 SkShader::kClamp_TileMode, matrix,
44 kNever_SkCopyPixelsMode));
45 return paint;
46 }
47
48 ///////////////////////////////////////////////////////////////////////////////
49
SkDraw()50 SkDraw::SkDraw() {
51 sk_bzero(this, sizeof(*this));
52 }
53
computeConservativeLocalClipBounds(SkRect * localBounds) const54 bool SkDraw::computeConservativeLocalClipBounds(SkRect* localBounds) const {
55 if (fRC->isEmpty()) {
56 return false;
57 }
58
59 SkMatrix inverse;
60 if (!fMatrix->invert(&inverse)) {
61 return false;
62 }
63
64 SkIRect devBounds = fRC->getBounds();
65 // outset to have slop for antialasing and hairlines
66 devBounds.outset(1, 1);
67 inverse.mapRect(localBounds, SkRect::Make(devBounds));
68 return true;
69 }
70
71 ///////////////////////////////////////////////////////////////////////////////
72
73 typedef void (*BitmapXferProc)(void* pixels, size_t bytes, uint32_t data);
74
D_Clear_BitmapXferProc(void * pixels,size_t bytes,uint32_t)75 static void D_Clear_BitmapXferProc(void* pixels, size_t bytes, uint32_t) {
76 sk_bzero(pixels, bytes);
77 }
78
D_Dst_BitmapXferProc(void *,size_t,uint32_t data)79 static void D_Dst_BitmapXferProc(void*, size_t, uint32_t data) {}
80
D32_Src_BitmapXferProc(void * pixels,size_t bytes,uint32_t data)81 static void D32_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
82 sk_memset32((uint32_t*)pixels, data, SkToInt(bytes >> 2));
83 }
84
D16_Src_BitmapXferProc(void * pixels,size_t bytes,uint32_t data)85 static void D16_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
86 sk_memset16((uint16_t*)pixels, data, SkToInt(bytes >> 1));
87 }
88
DA8_Src_BitmapXferProc(void * pixels,size_t bytes,uint32_t data)89 static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
90 memset(pixels, data, bytes);
91 }
92
ChooseBitmapXferProc(const SkPixmap & dst,const SkPaint & paint,uint32_t * data)93 static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& paint,
94 uint32_t* data) {
95 // todo: we can apply colorfilter up front if no shader, so we wouldn't
96 // need to abort this fastpath
97 if (paint.getShader() || paint.getColorFilter() || dst.colorSpace()) {
98 return nullptr;
99 }
100
101 SkBlendMode mode = paint.getBlendMode();
102 SkColor color = paint.getColor();
103
104 // collaps modes based on color...
105 if (SkBlendMode::kSrcOver == mode) {
106 unsigned alpha = SkColorGetA(color);
107 if (0 == alpha) {
108 mode = SkBlendMode::kDst;
109 } else if (0xFF == alpha) {
110 mode = SkBlendMode::kSrc;
111 }
112 }
113
114 switch (mode) {
115 case SkBlendMode::kClear:
116 // SkDebugf("--- D_Clear_BitmapXferProc\n");
117 return D_Clear_BitmapXferProc; // ignore data
118 case SkBlendMode::kDst:
119 // SkDebugf("--- D_Dst_BitmapXferProc\n");
120 return D_Dst_BitmapXferProc; // ignore data
121 case SkBlendMode::kSrc: {
122 /*
123 should I worry about dithering for the lower depths?
124 */
125 SkPMColor pmc = SkPreMultiplyColor(color);
126 switch (dst.colorType()) {
127 case kN32_SkColorType:
128 if (data) {
129 *data = pmc;
130 }
131 // SkDebugf("--- D32_Src_BitmapXferProc\n");
132 return D32_Src_BitmapXferProc;
133 case kRGB_565_SkColorType:
134 if (data) {
135 *data = SkPixel32ToPixel16(pmc);
136 }
137 // SkDebugf("--- D16_Src_BitmapXferProc\n");
138 return D16_Src_BitmapXferProc;
139 case kAlpha_8_SkColorType:
140 if (data) {
141 *data = SkGetPackedA32(pmc);
142 }
143 // SkDebugf("--- DA8_Src_BitmapXferProc\n");
144 return DA8_Src_BitmapXferProc;
145 default:
146 break;
147 }
148 break;
149 }
150 default:
151 break;
152 }
153 return nullptr;
154 }
155
CallBitmapXferProc(const SkPixmap & dst,const SkIRect & rect,BitmapXferProc proc,uint32_t procData)156 static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapXferProc proc,
157 uint32_t procData) {
158 int shiftPerPixel;
159 switch (dst.colorType()) {
160 case kN32_SkColorType:
161 shiftPerPixel = 2;
162 break;
163 case kRGB_565_SkColorType:
164 shiftPerPixel = 1;
165 break;
166 case kAlpha_8_SkColorType:
167 shiftPerPixel = 0;
168 break;
169 default:
170 SkDEBUGFAIL("Can't use xferproc on this config");
171 return;
172 }
173
174 uint8_t* pixels = (uint8_t*)dst.writable_addr();
175 SkASSERT(pixels);
176 const size_t rowBytes = dst.rowBytes();
177 const int widthBytes = rect.width() << shiftPerPixel;
178
179 // skip down to the first scanline and X position
180 pixels += rect.fTop * rowBytes + (rect.fLeft << shiftPerPixel);
181 for (int scans = rect.height() - 1; scans >= 0; --scans) {
182 proc(pixels, widthBytes, procData);
183 pixels += rowBytes;
184 }
185 }
186
drawPaint(const SkPaint & paint) const187 void SkDraw::drawPaint(const SkPaint& paint) const {
188 SkDEBUGCODE(this->validate();)
189
190 if (fRC->isEmpty()) {
191 return;
192 }
193
194 SkIRect devRect;
195 devRect.set(0, 0, fDst.width(), fDst.height());
196
197 if (fRC->isBW()) {
198 /* If we don't have a shader (i.e. we're just a solid color) we may
199 be faster to operate directly on the device bitmap, rather than invoking
200 a blitter. Esp. true for xfermodes, which require a colorshader to be
201 present, which is just redundant work. Since we're drawing everywhere
202 in the clip, we don't have to worry about antialiasing.
203 */
204 uint32_t procData = 0; // to avoid the warning
205 BitmapXferProc proc = ChooseBitmapXferProc(fDst, paint, &procData);
206 if (proc) {
207 if (D_Dst_BitmapXferProc == proc) { // nothing to do
208 return;
209 }
210
211 SkRegion::Iterator iter(fRC->bwRgn());
212 while (!iter.done()) {
213 CallBitmapXferProc(fDst, iter.rect(), proc, procData);
214 iter.next();
215 }
216 return;
217 }
218 }
219
220 // normal case: use a blitter
221 SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
222 SkScan::FillIRect(devRect, *fRC, blitter.get());
223 }
224
225 ///////////////////////////////////////////////////////////////////////////////
226
227 struct PtProcRec {
228 SkCanvas::PointMode fMode;
229 const SkPaint* fPaint;
230 const SkRegion* fClip;
231 const SkRasterClip* fRC;
232
233 // computed values
234 SkFixed fRadius;
235
236 typedef void (*Proc)(const PtProcRec&, const SkPoint devPts[], int count,
237 SkBlitter*);
238
239 bool init(SkCanvas::PointMode, const SkPaint&, const SkMatrix* matrix,
240 const SkRasterClip*);
241 Proc chooseProc(SkBlitter** blitter);
242
243 private:
244 SkAAClipBlitterWrapper fWrapper;
245 };
246
bw_pt_rect_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)247 static void bw_pt_rect_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
248 int count, SkBlitter* blitter) {
249 SkASSERT(rec.fClip->isRect());
250 const SkIRect& r = rec.fClip->getBounds();
251
252 for (int i = 0; i < count; i++) {
253 int x = SkScalarFloorToInt(devPts[i].fX);
254 int y = SkScalarFloorToInt(devPts[i].fY);
255 if (r.contains(x, y)) {
256 blitter->blitH(x, y, 1);
257 }
258 }
259 }
260
bw_pt_rect_16_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)261 static void bw_pt_rect_16_hair_proc(const PtProcRec& rec,
262 const SkPoint devPts[], int count,
263 SkBlitter* blitter) {
264 SkASSERT(rec.fRC->isRect());
265 const SkIRect& r = rec.fRC->getBounds();
266 uint32_t value;
267 const SkPixmap* dst = blitter->justAnOpaqueColor(&value);
268 SkASSERT(dst);
269
270 uint16_t* addr = dst->writable_addr16(0, 0);
271 size_t rb = dst->rowBytes();
272
273 for (int i = 0; i < count; i++) {
274 int x = SkScalarFloorToInt(devPts[i].fX);
275 int y = SkScalarFloorToInt(devPts[i].fY);
276 if (r.contains(x, y)) {
277 ((uint16_t*)((char*)addr + y * rb))[x] = SkToU16(value);
278 }
279 }
280 }
281
bw_pt_rect_32_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)282 static void bw_pt_rect_32_hair_proc(const PtProcRec& rec,
283 const SkPoint devPts[], int count,
284 SkBlitter* blitter) {
285 SkASSERT(rec.fRC->isRect());
286 const SkIRect& r = rec.fRC->getBounds();
287 uint32_t value;
288 const SkPixmap* dst = blitter->justAnOpaqueColor(&value);
289 SkASSERT(dst);
290
291 SkPMColor* addr = dst->writable_addr32(0, 0);
292 size_t rb = dst->rowBytes();
293
294 for (int i = 0; i < count; i++) {
295 int x = SkScalarFloorToInt(devPts[i].fX);
296 int y = SkScalarFloorToInt(devPts[i].fY);
297 if (r.contains(x, y)) {
298 ((SkPMColor*)((char*)addr + y * rb))[x] = value;
299 }
300 }
301 }
302
bw_pt_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)303 static void bw_pt_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
304 int count, SkBlitter* blitter) {
305 for (int i = 0; i < count; i++) {
306 int x = SkScalarFloorToInt(devPts[i].fX);
307 int y = SkScalarFloorToInt(devPts[i].fY);
308 if (rec.fClip->contains(x, y)) {
309 blitter->blitH(x, y, 1);
310 }
311 }
312 }
313
bw_line_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)314 static void bw_line_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
315 int count, SkBlitter* blitter) {
316 for (int i = 0; i < count; i += 2) {
317 SkScan::HairLine(&devPts[i], 2, *rec.fRC, blitter);
318 }
319 }
320
bw_poly_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)321 static void bw_poly_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
322 int count, SkBlitter* blitter) {
323 SkScan::HairLine(devPts, count, *rec.fRC, blitter);
324 }
325
326 // aa versions
327
aa_line_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)328 static void aa_line_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
329 int count, SkBlitter* blitter) {
330 for (int i = 0; i < count; i += 2) {
331 SkScan::AntiHairLine(&devPts[i], 2, *rec.fRC, blitter);
332 }
333 }
334
aa_poly_hair_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)335 static void aa_poly_hair_proc(const PtProcRec& rec, const SkPoint devPts[],
336 int count, SkBlitter* blitter) {
337 SkScan::AntiHairLine(devPts, count, *rec.fRC, blitter);
338 }
339
340 // square procs (strokeWidth > 0 but matrix is square-scale (sx == sy)
341
bw_square_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)342 static void bw_square_proc(const PtProcRec& rec, const SkPoint devPts[],
343 int count, SkBlitter* blitter) {
344 const SkFixed radius = rec.fRadius;
345 for (int i = 0; i < count; i++) {
346 SkFixed x = SkScalarToFixed(devPts[i].fX);
347 SkFixed y = SkScalarToFixed(devPts[i].fY);
348
349 SkXRect r;
350 r.fLeft = x - radius;
351 r.fTop = y - radius;
352 r.fRight = x + radius;
353 r.fBottom = y + radius;
354
355 SkScan::FillXRect(r, *rec.fRC, blitter);
356 }
357 }
358
aa_square_proc(const PtProcRec & rec,const SkPoint devPts[],int count,SkBlitter * blitter)359 static void aa_square_proc(const PtProcRec& rec, const SkPoint devPts[],
360 int count, SkBlitter* blitter) {
361 const SkFixed radius = rec.fRadius;
362 for (int i = 0; i < count; i++) {
363 SkFixed x = SkScalarToFixed(devPts[i].fX);
364 SkFixed y = SkScalarToFixed(devPts[i].fY);
365
366 SkXRect r;
367 r.fLeft = x - radius;
368 r.fTop = y - radius;
369 r.fRight = x + radius;
370 r.fBottom = y + radius;
371
372 SkScan::AntiFillXRect(r, *rec.fRC, blitter);
373 }
374 }
375
376 // If this guy returns true, then chooseProc() must return a valid proc
init(SkCanvas::PointMode mode,const SkPaint & paint,const SkMatrix * matrix,const SkRasterClip * rc)377 bool PtProcRec::init(SkCanvas::PointMode mode, const SkPaint& paint,
378 const SkMatrix* matrix, const SkRasterClip* rc) {
379 if ((unsigned)mode > (unsigned)SkCanvas::kPolygon_PointMode) {
380 return false;
381 }
382
383 if (paint.getPathEffect()) {
384 return false;
385 }
386 SkScalar width = paint.getStrokeWidth();
387 if (0 == width) {
388 fMode = mode;
389 fPaint = &paint;
390 fClip = nullptr;
391 fRC = rc;
392 fRadius = SK_FixedHalf;
393 return true;
394 }
395 if (paint.getStrokeCap() != SkPaint::kRound_Cap &&
396 matrix->isScaleTranslate() && SkCanvas::kPoints_PointMode == mode) {
397 SkScalar sx = matrix->get(SkMatrix::kMScaleX);
398 SkScalar sy = matrix->get(SkMatrix::kMScaleY);
399 if (SkScalarNearlyZero(sx - sy)) {
400 if (sx < 0) {
401 sx = -sx;
402 }
403
404 fMode = mode;
405 fPaint = &paint;
406 fClip = nullptr;
407 fRC = rc;
408 fRadius = SkScalarToFixed(width * sx) >> 1;
409 return true;
410 }
411 }
412 return false;
413 }
414
chooseProc(SkBlitter ** blitterPtr)415 PtProcRec::Proc PtProcRec::chooseProc(SkBlitter** blitterPtr) {
416 Proc proc = nullptr;
417
418 SkBlitter* blitter = *blitterPtr;
419 if (fRC->isBW()) {
420 fClip = &fRC->bwRgn();
421 } else {
422 fWrapper.init(*fRC, blitter);
423 fClip = &fWrapper.getRgn();
424 blitter = fWrapper.getBlitter();
425 *blitterPtr = blitter;
426 }
427
428 // for our arrays
429 SkASSERT(0 == SkCanvas::kPoints_PointMode);
430 SkASSERT(1 == SkCanvas::kLines_PointMode);
431 SkASSERT(2 == SkCanvas::kPolygon_PointMode);
432 SkASSERT((unsigned)fMode <= (unsigned)SkCanvas::kPolygon_PointMode);
433
434 if (fPaint->isAntiAlias()) {
435 if (0 == fPaint->getStrokeWidth()) {
436 static const Proc gAAProcs[] = {
437 aa_square_proc, aa_line_hair_proc, aa_poly_hair_proc
438 };
439 proc = gAAProcs[fMode];
440 } else if (fPaint->getStrokeCap() != SkPaint::kRound_Cap) {
441 SkASSERT(SkCanvas::kPoints_PointMode == fMode);
442 proc = aa_square_proc;
443 }
444 } else { // BW
445 if (fRadius <= SK_FixedHalf) { // small radii and hairline
446 if (SkCanvas::kPoints_PointMode == fMode && fClip->isRect()) {
447 uint32_t value;
448 const SkPixmap* bm = blitter->justAnOpaqueColor(&value);
449 if (bm && kRGB_565_SkColorType == bm->colorType()) {
450 proc = bw_pt_rect_16_hair_proc;
451 } else if (bm && kN32_SkColorType == bm->colorType()) {
452 proc = bw_pt_rect_32_hair_proc;
453 } else {
454 proc = bw_pt_rect_hair_proc;
455 }
456 } else {
457 static Proc gBWProcs[] = {
458 bw_pt_hair_proc, bw_line_hair_proc, bw_poly_hair_proc
459 };
460 proc = gBWProcs[fMode];
461 }
462 } else {
463 proc = bw_square_proc;
464 }
465 }
466 return proc;
467 }
468
469 // each of these costs 8-bytes of stack space, so don't make it too large
470 // must be even for lines/polygon to work
471 #define MAX_DEV_PTS 32
472
drawPoints(SkCanvas::PointMode mode,size_t count,const SkPoint pts[],const SkPaint & paint,SkBaseDevice * device) const473 void SkDraw::drawPoints(SkCanvas::PointMode mode, size_t count,
474 const SkPoint pts[], const SkPaint& paint,
475 SkBaseDevice* device) const {
476 // if we're in lines mode, force count to be even
477 if (SkCanvas::kLines_PointMode == mode) {
478 count &= ~(size_t)1;
479 }
480
481 if ((long)count <= 0) {
482 return;
483 }
484
485 SkASSERT(pts != nullptr);
486 SkDEBUGCODE(this->validate();)
487
488 // nothing to draw
489 if (fRC->isEmpty()) {
490 return;
491 }
492
493 PtProcRec rec;
494 if (!device && rec.init(mode, paint, fMatrix, fRC)) {
495 SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
496
497 SkPoint devPts[MAX_DEV_PTS];
498 const SkMatrix* matrix = fMatrix;
499 SkBlitter* bltr = blitter.get();
500 PtProcRec::Proc proc = rec.chooseProc(&bltr);
501 // we have to back up subsequent passes if we're in polygon mode
502 const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
503
504 do {
505 int n = SkToInt(count);
506 if (n > MAX_DEV_PTS) {
507 n = MAX_DEV_PTS;
508 }
509 matrix->mapPoints(devPts, pts, n);
510 proc(rec, devPts, n, bltr);
511 pts += n - backup;
512 SkASSERT(SkToInt(count) >= n);
513 count -= n;
514 if (count > 0) {
515 count += backup;
516 }
517 } while (count != 0);
518 } else {
519 switch (mode) {
520 case SkCanvas::kPoints_PointMode: {
521 // temporarily mark the paint as filling.
522 SkPaint newPaint(paint);
523 newPaint.setStyle(SkPaint::kFill_Style);
524
525 SkScalar width = newPaint.getStrokeWidth();
526 SkScalar radius = SkScalarHalf(width);
527
528 if (newPaint.getStrokeCap() == SkPaint::kRound_Cap) {
529 SkPath path;
530 SkMatrix preMatrix;
531
532 path.addCircle(0, 0, radius);
533 for (size_t i = 0; i < count; i++) {
534 preMatrix.setTranslate(pts[i].fX, pts[i].fY);
535 // pass true for the last point, since we can modify
536 // then path then
537 path.setIsVolatile((count-1) == i);
538 if (device) {
539 device->drawPath(path, newPaint, &preMatrix, (count-1) == i);
540 } else {
541 this->drawPath(path, newPaint, &preMatrix, (count-1) == i);
542 }
543 }
544 } else {
545 SkRect r;
546
547 for (size_t i = 0; i < count; i++) {
548 r.fLeft = pts[i].fX - radius;
549 r.fTop = pts[i].fY - radius;
550 r.fRight = r.fLeft + width;
551 r.fBottom = r.fTop + width;
552 if (device) {
553 device->drawRect(r, newPaint);
554 } else {
555 this->drawRect(r, newPaint);
556 }
557 }
558 }
559 break;
560 }
561 case SkCanvas::kLines_PointMode:
562 if (2 == count && paint.getPathEffect()) {
563 // most likely a dashed line - see if it is one of the ones
564 // we can accelerate
565 SkStrokeRec rec(paint);
566 SkPathEffect::PointData pointData;
567
568 SkPath path;
569 path.moveTo(pts[0]);
570 path.lineTo(pts[1]);
571
572 SkRect cullRect = SkRect::Make(fRC->getBounds());
573
574 if (paint.getPathEffect()->asPoints(&pointData, path, rec,
575 *fMatrix, &cullRect)) {
576 // 'asPoints' managed to find some fast path
577
578 SkPaint newP(paint);
579 newP.setPathEffect(nullptr);
580 newP.setStyle(SkPaint::kFill_Style);
581
582 if (!pointData.fFirst.isEmpty()) {
583 if (device) {
584 device->drawPath(pointData.fFirst, newP);
585 } else {
586 this->drawPath(pointData.fFirst, newP);
587 }
588 }
589
590 if (!pointData.fLast.isEmpty()) {
591 if (device) {
592 device->drawPath(pointData.fLast, newP);
593 } else {
594 this->drawPath(pointData.fLast, newP);
595 }
596 }
597
598 if (pointData.fSize.fX == pointData.fSize.fY) {
599 // The rest of the dashed line can just be drawn as points
600 SkASSERT(pointData.fSize.fX == SkScalarHalf(newP.getStrokeWidth()));
601
602 if (SkPathEffect::PointData::kCircles_PointFlag & pointData.fFlags) {
603 newP.setStrokeCap(SkPaint::kRound_Cap);
604 } else {
605 newP.setStrokeCap(SkPaint::kButt_Cap);
606 }
607
608 if (device) {
609 device->drawPoints(SkCanvas::kPoints_PointMode,
610 pointData.fNumPoints,
611 pointData.fPoints,
612 newP);
613 } else {
614 this->drawPoints(SkCanvas::kPoints_PointMode,
615 pointData.fNumPoints,
616 pointData.fPoints,
617 newP,
618 device);
619 }
620 break;
621 } else {
622 // The rest of the dashed line must be drawn as rects
623 SkASSERT(!(SkPathEffect::PointData::kCircles_PointFlag &
624 pointData.fFlags));
625
626 SkRect r;
627
628 for (int i = 0; i < pointData.fNumPoints; ++i) {
629 r.set(pointData.fPoints[i].fX - pointData.fSize.fX,
630 pointData.fPoints[i].fY - pointData.fSize.fY,
631 pointData.fPoints[i].fX + pointData.fSize.fX,
632 pointData.fPoints[i].fY + pointData.fSize.fY);
633 if (device) {
634 device->drawRect(r, newP);
635 } else {
636 this->drawRect(r, newP);
637 }
638 }
639 }
640
641 break;
642 }
643 }
644 // couldn't take fast path so fall through!
645 case SkCanvas::kPolygon_PointMode: {
646 count -= 1;
647 SkPath path;
648 SkPaint p(paint);
649 p.setStyle(SkPaint::kStroke_Style);
650 size_t inc = (SkCanvas::kLines_PointMode == mode) ? 2 : 1;
651 path.setIsVolatile(true);
652 for (size_t i = 0; i < count; i += inc) {
653 path.moveTo(pts[i]);
654 path.lineTo(pts[i+1]);
655 if (device) {
656 device->drawPath(path, p, nullptr, true);
657 } else {
658 this->drawPath(path, p, nullptr, true);
659 }
660 path.rewind();
661 }
662 break;
663 }
664 }
665 }
666 }
667
compute_stroke_size(const SkPaint & paint,const SkMatrix & matrix)668 static inline SkPoint compute_stroke_size(const SkPaint& paint, const SkMatrix& matrix) {
669 SkASSERT(matrix.rectStaysRect());
670 SkASSERT(SkPaint::kFill_Style != paint.getStyle());
671
672 SkVector size;
673 SkPoint pt = { paint.getStrokeWidth(), paint.getStrokeWidth() };
674 matrix.mapVectors(&size, &pt, 1);
675 return SkPoint::Make(SkScalarAbs(size.fX), SkScalarAbs(size.fY));
676 }
677
easy_rect_join(const SkPaint & paint,const SkMatrix & matrix,SkPoint * strokeSize)678 static bool easy_rect_join(const SkPaint& paint, const SkMatrix& matrix,
679 SkPoint* strokeSize) {
680 if (SkPaint::kMiter_Join != paint.getStrokeJoin() ||
681 paint.getStrokeMiter() < SK_ScalarSqrt2) {
682 return false;
683 }
684
685 *strokeSize = compute_stroke_size(paint, matrix);
686 return true;
687 }
688
ComputeRectType(const SkPaint & paint,const SkMatrix & matrix,SkPoint * strokeSize)689 SkDraw::RectType SkDraw::ComputeRectType(const SkPaint& paint,
690 const SkMatrix& matrix,
691 SkPoint* strokeSize) {
692 RectType rtype;
693 const SkScalar width = paint.getStrokeWidth();
694 const bool zeroWidth = (0 == width);
695 SkPaint::Style style = paint.getStyle();
696
697 if ((SkPaint::kStrokeAndFill_Style == style) && zeroWidth) {
698 style = SkPaint::kFill_Style;
699 }
700
701 if (paint.getPathEffect() || paint.getMaskFilter() ||
702 paint.getRasterizer() || !matrix.rectStaysRect() ||
703 SkPaint::kStrokeAndFill_Style == style) {
704 rtype = kPath_RectType;
705 } else if (SkPaint::kFill_Style == style) {
706 rtype = kFill_RectType;
707 } else if (zeroWidth) {
708 rtype = kHair_RectType;
709 } else if (easy_rect_join(paint, matrix, strokeSize)) {
710 rtype = kStroke_RectType;
711 } else {
712 rtype = kPath_RectType;
713 }
714 return rtype;
715 }
716
rect_points(const SkRect & r)717 static const SkPoint* rect_points(const SkRect& r) {
718 return SkTCast<const SkPoint*>(&r);
719 }
720
rect_points(SkRect & r)721 static SkPoint* rect_points(SkRect& r) {
722 return SkTCast<SkPoint*>(&r);
723 }
724
drawRect(const SkRect & prePaintRect,const SkPaint & paint,const SkMatrix * paintMatrix,const SkRect * postPaintRect) const725 void SkDraw::drawRect(const SkRect& prePaintRect, const SkPaint& paint,
726 const SkMatrix* paintMatrix, const SkRect* postPaintRect) const {
727 SkDEBUGCODE(this->validate();)
728
729 // nothing to draw
730 if (fRC->isEmpty()) {
731 return;
732 }
733
734 const SkMatrix* matrix;
735 SkMatrix combinedMatrixStorage;
736 if (paintMatrix) {
737 SkASSERT(postPaintRect);
738 combinedMatrixStorage.setConcat(*fMatrix, *paintMatrix);
739 matrix = &combinedMatrixStorage;
740 } else {
741 SkASSERT(!postPaintRect);
742 matrix = fMatrix;
743 }
744
745 SkPoint strokeSize;
746 RectType rtype = ComputeRectType(paint, *fMatrix, &strokeSize);
747
748 if (kPath_RectType == rtype) {
749 SkDraw draw(*this);
750 if (paintMatrix) {
751 draw.fMatrix = matrix;
752 }
753 SkPath tmp;
754 tmp.addRect(prePaintRect);
755 tmp.setFillType(SkPath::kWinding_FillType);
756 draw.drawPath(tmp, paint, nullptr, true);
757 return;
758 }
759
760 SkRect devRect;
761 const SkRect& paintRect = paintMatrix ? *postPaintRect : prePaintRect;
762 // skip the paintMatrix when transforming the rect by the CTM
763 fMatrix->mapPoints(rect_points(devRect), rect_points(paintRect), 2);
764 devRect.sort();
765
766 // look for the quick exit, before we build a blitter
767 SkRect bbox = devRect;
768 if (paint.getStyle() != SkPaint::kFill_Style) {
769 // extra space for hairlines
770 if (paint.getStrokeWidth() == 0) {
771 bbox.outset(1, 1);
772 } else {
773 // For kStroke_RectType, strokeSize is already computed.
774 const SkPoint& ssize = (kStroke_RectType == rtype)
775 ? strokeSize
776 : compute_stroke_size(paint, *fMatrix);
777 bbox.outset(SkScalarHalf(ssize.x()), SkScalarHalf(ssize.y()));
778 }
779 }
780
781 SkIRect ir = bbox.roundOut();
782 if (fRC->quickReject(ir)) {
783 return;
784 }
785
786 SkDeviceLooper looper(fDst, *fRC, ir, paint.isAntiAlias());
787 while (looper.next()) {
788 SkRect localDevRect;
789 looper.mapRect(&localDevRect, devRect);
790 SkMatrix localMatrix;
791 looper.mapMatrix(&localMatrix, *matrix);
792
793 SkAutoBlitterChoose blitterStorage(looper.getPixmap(), localMatrix, paint);
794 const SkRasterClip& clip = looper.getRC();
795 SkBlitter* blitter = blitterStorage.get();
796
797 // we want to "fill" if we are kFill or kStrokeAndFill, since in the latter
798 // case we are also hairline (if we've gotten to here), which devolves to
799 // effectively just kFill
800 switch (rtype) {
801 case kFill_RectType:
802 if (paint.isAntiAlias()) {
803 SkScan::AntiFillRect(localDevRect, clip, blitter);
804 } else {
805 SkScan::FillRect(localDevRect, clip, blitter);
806 }
807 break;
808 case kStroke_RectType:
809 if (paint.isAntiAlias()) {
810 SkScan::AntiFrameRect(localDevRect, strokeSize, clip, blitter);
811 } else {
812 SkScan::FrameRect(localDevRect, strokeSize, clip, blitter);
813 }
814 break;
815 case kHair_RectType:
816 if (paint.isAntiAlias()) {
817 SkScan::AntiHairRect(localDevRect, clip, blitter);
818 } else {
819 SkScan::HairRect(localDevRect, clip, blitter);
820 }
821 break;
822 default:
823 SkDEBUGFAIL("bad rtype");
824 }
825 }
826 }
827
drawDevMask(const SkMask & srcM,const SkPaint & paint) const828 void SkDraw::drawDevMask(const SkMask& srcM, const SkPaint& paint) const {
829 if (srcM.fBounds.isEmpty()) {
830 return;
831 }
832
833 const SkMask* mask = &srcM;
834
835 SkMask dstM;
836 if (paint.getMaskFilter() &&
837 paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, nullptr)) {
838 mask = &dstM;
839 }
840 SkAutoMaskFreeImage ami(dstM.fImage);
841
842 SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
843 SkBlitter* blitter = blitterChooser.get();
844
845 SkAAClipBlitterWrapper wrapper;
846 const SkRegion* clipRgn;
847
848 if (fRC->isBW()) {
849 clipRgn = &fRC->bwRgn();
850 } else {
851 wrapper.init(*fRC, blitter);
852 clipRgn = &wrapper.getRgn();
853 blitter = wrapper.getBlitter();
854 }
855 blitter->blitMaskRegion(*mask, *clipRgn);
856 }
857
fast_len(const SkVector & vec)858 static SkScalar fast_len(const SkVector& vec) {
859 SkScalar x = SkScalarAbs(vec.fX);
860 SkScalar y = SkScalarAbs(vec.fY);
861 if (x < y) {
862 SkTSwap(x, y);
863 }
864 return x + SkScalarHalf(y);
865 }
866
SkDrawTreatAAStrokeAsHairline(SkScalar strokeWidth,const SkMatrix & matrix,SkScalar * coverage)867 bool SkDrawTreatAAStrokeAsHairline(SkScalar strokeWidth, const SkMatrix& matrix,
868 SkScalar* coverage) {
869 SkASSERT(strokeWidth > 0);
870 // We need to try to fake a thick-stroke with a modulated hairline.
871
872 if (matrix.hasPerspective()) {
873 return false;
874 }
875
876 SkVector src[2], dst[2];
877 src[0].set(strokeWidth, 0);
878 src[1].set(0, strokeWidth);
879 matrix.mapVectors(dst, src, 2);
880 SkScalar len0 = fast_len(dst[0]);
881 SkScalar len1 = fast_len(dst[1]);
882 if (len0 <= SK_Scalar1 && len1 <= SK_Scalar1) {
883 if (coverage) {
884 *coverage = SkScalarAve(len0, len1);
885 }
886 return true;
887 }
888 return false;
889 }
890
drawRRect(const SkRRect & rrect,const SkPaint & paint) const891 void SkDraw::drawRRect(const SkRRect& rrect, const SkPaint& paint) const {
892 SkDEBUGCODE(this->validate());
893
894 if (fRC->isEmpty()) {
895 return;
896 }
897
898 {
899 // TODO: Investigate optimizing these options. They are in the same
900 // order as SkDraw::drawPath, which handles each case. It may be
901 // that there is no way to optimize for these using the SkRRect path.
902 SkScalar coverage;
903 if (SkDrawTreatAsHairline(paint, *fMatrix, &coverage)) {
904 goto DRAW_PATH;
905 }
906
907 if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
908 goto DRAW_PATH;
909 }
910
911 if (paint.getRasterizer()) {
912 goto DRAW_PATH;
913 }
914 }
915
916 if (paint.getMaskFilter()) {
917 // Transform the rrect into device space.
918 SkRRect devRRect;
919 if (rrect.transform(*fMatrix, &devRRect)) {
920 SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
921 if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC, blitter.get())) {
922 return; // filterRRect() called the blitter, so we're done
923 }
924 }
925 }
926
927 DRAW_PATH:
928 // Now fall back to the default case of using a path.
929 SkPath path;
930 path.addRRect(rrect);
931 this->drawPath(path, paint, nullptr, true);
932 }
933
ComputeResScaleForStroking(const SkMatrix & matrix)934 SkScalar SkDraw::ComputeResScaleForStroking(const SkMatrix& matrix) {
935 if (!matrix.hasPerspective()) {
936 SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
937 SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX], matrix[SkMatrix::kMScaleY]);
938 if (SkScalarsAreFinite(sx, sy)) {
939 SkScalar scale = SkTMax(sx, sy);
940 if (scale > 0) {
941 return scale;
942 }
943 }
944 }
945 return 1;
946 }
947
drawDevPath(const SkPath & devPath,const SkPaint & paint,bool drawCoverage,SkBlitter * customBlitter,bool doFill) const948 void SkDraw::drawDevPath(const SkPath& devPath, const SkPaint& paint, bool drawCoverage,
949 SkBlitter* customBlitter, bool doFill) const {
950 // Do a conservative quick-reject test, since a looper or other modifier may have moved us
951 // out of range.
952 if (!devPath.isInverseFillType()) {
953 // If we're a H or V line, our bounds will be empty. So we bloat here just so we don't
954 // appear empty to the intersects call. This also gives us slop in case we're antialiasing
955 SkRect pathBounds = devPath.getBounds().makeOutset(1, 1);
956
957 if (paint.getMaskFilter()) {
958 paint.getMaskFilter()->computeFastBounds(pathBounds, &pathBounds);
959
960 // Need to outset the path to work-around a bug in blurmaskfilter. When that is fixed
961 // we can remove this hack. See skbug.com/5542
962 pathBounds.outset(7, 7);
963 }
964
965 // Now compare against the clip's bounds
966 if (!SkRect::Make(fRC->getBounds()).intersects(pathBounds)) {
967 return;
968 }
969 }
970
971 SkBlitter* blitter = nullptr;
972 SkAutoBlitterChoose blitterStorage;
973 if (nullptr == customBlitter) {
974 blitterStorage.choose(fDst, *fMatrix, paint, drawCoverage);
975 blitter = blitterStorage.get();
976 } else {
977 blitter = customBlitter;
978 }
979
980 if (paint.getMaskFilter()) {
981 SkStrokeRec::InitStyle style = doFill ? SkStrokeRec::kFill_InitStyle
982 : SkStrokeRec::kHairline_InitStyle;
983 if (paint.getMaskFilter()->filterPath(devPath, *fMatrix, *fRC, blitter, style)) {
984 return; // filterPath() called the blitter, so we're done
985 }
986 }
987
988 void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*);
989 if (doFill) {
990 if (paint.isAntiAlias()) {
991 proc = SkScan::AntiFillPath;
992 } else {
993 proc = SkScan::FillPath;
994 }
995 } else { // hairline
996 if (paint.isAntiAlias()) {
997 switch (paint.getStrokeCap()) {
998 case SkPaint::kButt_Cap:
999 proc = SkScan::AntiHairPath;
1000 break;
1001 case SkPaint::kSquare_Cap:
1002 proc = SkScan::AntiHairSquarePath;
1003 break;
1004 case SkPaint::kRound_Cap:
1005 proc = SkScan::AntiHairRoundPath;
1006 break;
1007 default:
1008 proc SK_INIT_TO_AVOID_WARNING;
1009 SkDEBUGFAIL("unknown paint cap type");
1010 }
1011 } else {
1012 switch (paint.getStrokeCap()) {
1013 case SkPaint::kButt_Cap:
1014 proc = SkScan::HairPath;
1015 break;
1016 case SkPaint::kSquare_Cap:
1017 proc = SkScan::HairSquarePath;
1018 break;
1019 case SkPaint::kRound_Cap:
1020 proc = SkScan::HairRoundPath;
1021 break;
1022 default:
1023 proc SK_INIT_TO_AVOID_WARNING;
1024 SkDEBUGFAIL("unknown paint cap type");
1025 }
1026 }
1027 }
1028 proc(devPath, *fRC, blitter);
1029 }
1030
drawPath(const SkPath & origSrcPath,const SkPaint & origPaint,const SkMatrix * prePathMatrix,bool pathIsMutable,bool drawCoverage,SkBlitter * customBlitter) const1031 void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
1032 const SkMatrix* prePathMatrix, bool pathIsMutable,
1033 bool drawCoverage, SkBlitter* customBlitter) const {
1034 SkDEBUGCODE(this->validate();)
1035
1036 // nothing to draw
1037 if (fRC->isEmpty()) {
1038 return;
1039 }
1040
1041 SkPath* pathPtr = (SkPath*)&origSrcPath;
1042 bool doFill = true;
1043 SkPath tmpPath;
1044 SkMatrix tmpMatrix;
1045 const SkMatrix* matrix = fMatrix;
1046 tmpPath.setIsVolatile(true);
1047
1048 if (prePathMatrix) {
1049 if (origPaint.getPathEffect() || origPaint.getStyle() != SkPaint::kFill_Style ||
1050 origPaint.getRasterizer()) {
1051 SkPath* result = pathPtr;
1052
1053 if (!pathIsMutable) {
1054 result = &tmpPath;
1055 pathIsMutable = true;
1056 }
1057 pathPtr->transform(*prePathMatrix, result);
1058 pathPtr = result;
1059 } else {
1060 tmpMatrix.setConcat(*matrix, *prePathMatrix);
1061 matrix = &tmpMatrix;
1062 }
1063 }
1064 // at this point we're done with prePathMatrix
1065 SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
1066
1067 SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
1068
1069 {
1070 SkScalar coverage;
1071 if (SkDrawTreatAsHairline(origPaint, *matrix, &coverage)) {
1072 if (SK_Scalar1 == coverage) {
1073 paint.writable()->setStrokeWidth(0);
1074 } else if (SkBlendMode_SupportsCoverageAsAlpha(origPaint.getBlendMode())) {
1075 U8CPU newAlpha;
1076 #if 0
1077 newAlpha = SkToU8(SkScalarRoundToInt(coverage *
1078 origPaint.getAlpha()));
1079 #else
1080 // this is the old technique, which we preserve for now so
1081 // we don't change previous results (testing)
1082 // the new way seems fine, its just (a tiny bit) different
1083 int scale = (int)(coverage * 256);
1084 newAlpha = origPaint.getAlpha() * scale >> 8;
1085 #endif
1086 SkPaint* writablePaint = paint.writable();
1087 writablePaint->setStrokeWidth(0);
1088 writablePaint->setAlpha(newAlpha);
1089 }
1090 }
1091 }
1092
1093 if (paint->getPathEffect() || paint->getStyle() != SkPaint::kFill_Style) {
1094 SkRect cullRect;
1095 const SkRect* cullRectPtr = nullptr;
1096 if (this->computeConservativeLocalClipBounds(&cullRect)) {
1097 cullRectPtr = &cullRect;
1098 }
1099 doFill = paint->getFillPath(*pathPtr, &tmpPath, cullRectPtr,
1100 ComputeResScaleForStroking(*fMatrix));
1101 pathPtr = &tmpPath;
1102 }
1103
1104 if (paint->getRasterizer()) {
1105 SkMask mask;
1106 if (paint->getRasterizer()->rasterize(*pathPtr, *matrix,
1107 &fRC->getBounds(), paint->getMaskFilter(), &mask,
1108 SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
1109 this->drawDevMask(mask, *paint);
1110 SkMask::FreeImage(mask.fImage);
1111 }
1112 return;
1113 }
1114
1115 // avoid possibly allocating a new path in transform if we can
1116 SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
1117
1118 // transform the path into device space
1119 pathPtr->transform(*matrix, devPathPtr);
1120
1121 this->drawDevPath(*devPathPtr, *paint, drawCoverage, customBlitter, doFill);
1122 }
1123
drawBitmapAsMask(const SkBitmap & bitmap,const SkPaint & paint) const1124 void SkDraw::drawBitmapAsMask(const SkBitmap& bitmap, const SkPaint& paint) const {
1125 SkASSERT(bitmap.colorType() == kAlpha_8_SkColorType);
1126
1127 if (SkTreatAsSprite(*fMatrix, bitmap.dimensions(), paint)) {
1128 int ix = SkScalarRoundToInt(fMatrix->getTranslateX());
1129 int iy = SkScalarRoundToInt(fMatrix->getTranslateY());
1130
1131 SkPixmap pmap;
1132 if (!bitmap.peekPixels(&pmap)) {
1133 return;
1134 }
1135 SkMask mask;
1136 mask.fBounds.set(ix, iy, ix + pmap.width(), iy + pmap.height());
1137 mask.fFormat = SkMask::kA8_Format;
1138 mask.fRowBytes = SkToU32(pmap.rowBytes());
1139 // fImage is typed as writable, but in this case it is used read-only
1140 mask.fImage = (uint8_t*)pmap.addr8(0, 0);
1141
1142 this->drawDevMask(mask, paint);
1143 } else { // need to xform the bitmap first
1144 SkRect r;
1145 SkMask mask;
1146
1147 r.set(0, 0,
1148 SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
1149 fMatrix->mapRect(&r);
1150 r.round(&mask.fBounds);
1151
1152 // set the mask's bounds to the transformed bitmap-bounds,
1153 // clipped to the actual device
1154 {
1155 SkIRect devBounds;
1156 devBounds.set(0, 0, fDst.width(), fDst.height());
1157 // need intersect(l, t, r, b) on irect
1158 if (!mask.fBounds.intersect(devBounds)) {
1159 return;
1160 }
1161 }
1162
1163 mask.fFormat = SkMask::kA8_Format;
1164 mask.fRowBytes = SkAlign4(mask.fBounds.width());
1165 size_t size = mask.computeImageSize();
1166 if (0 == size) {
1167 // the mask is too big to allocated, draw nothing
1168 return;
1169 }
1170
1171 // allocate (and clear) our temp buffer to hold the transformed bitmap
1172 SkAutoTMalloc<uint8_t> storage(size);
1173 mask.fImage = storage.get();
1174 memset(mask.fImage, 0, size);
1175
1176 // now draw our bitmap(src) into mask(dst), transformed by the matrix
1177 {
1178 SkBitmap device;
1179 device.installPixels(SkImageInfo::MakeA8(mask.fBounds.width(), mask.fBounds.height()),
1180 mask.fImage, mask.fRowBytes);
1181
1182 SkCanvas c(device);
1183 // need the unclipped top/left for the translate
1184 c.translate(-SkIntToScalar(mask.fBounds.fLeft),
1185 -SkIntToScalar(mask.fBounds.fTop));
1186 c.concat(*fMatrix);
1187
1188 // We can't call drawBitmap, or we'll infinitely recurse. Instead
1189 // we manually build a shader and draw that into our new mask
1190 SkPaint tmpPaint;
1191 tmpPaint.setFlags(paint.getFlags());
1192 tmpPaint.setFilterQuality(paint.getFilterQuality());
1193 SkPaint paintWithShader = make_paint_with_image(tmpPaint, bitmap);
1194 SkRect rr;
1195 rr.set(0, 0, SkIntToScalar(bitmap.width()),
1196 SkIntToScalar(bitmap.height()));
1197 c.drawRect(rr, paintWithShader);
1198 }
1199 this->drawDevMask(mask, paint);
1200 }
1201 }
1202
clipped_out(const SkMatrix & m,const SkRasterClip & c,const SkRect & srcR)1203 static bool clipped_out(const SkMatrix& m, const SkRasterClip& c,
1204 const SkRect& srcR) {
1205 SkRect dstR;
1206 m.mapRect(&dstR, srcR);
1207 return c.quickReject(dstR.roundOut());
1208 }
1209
clipped_out(const SkMatrix & matrix,const SkRasterClip & clip,int width,int height)1210 static bool clipped_out(const SkMatrix& matrix, const SkRasterClip& clip,
1211 int width, int height) {
1212 SkRect r;
1213 r.set(0, 0, SkIntToScalar(width), SkIntToScalar(height));
1214 return clipped_out(matrix, clip, r);
1215 }
1216
clipHandlesSprite(const SkRasterClip & clip,int x,int y,const SkPixmap & pmap)1217 static bool clipHandlesSprite(const SkRasterClip& clip, int x, int y, const SkPixmap& pmap) {
1218 return clip.isBW() || clip.quickContains(x, y, x + pmap.width(), y + pmap.height());
1219 }
1220
drawBitmap(const SkBitmap & bitmap,const SkMatrix & prematrix,const SkRect * dstBounds,const SkPaint & origPaint) const1221 void SkDraw::drawBitmap(const SkBitmap& bitmap, const SkMatrix& prematrix,
1222 const SkRect* dstBounds, const SkPaint& origPaint) const {
1223 SkDEBUGCODE(this->validate();)
1224
1225 // nothing to draw
1226 if (fRC->isEmpty() ||
1227 bitmap.width() == 0 || bitmap.height() == 0 ||
1228 bitmap.colorType() == kUnknown_SkColorType) {
1229 return;
1230 }
1231
1232 SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
1233 if (origPaint.getStyle() != SkPaint::kFill_Style) {
1234 paint.writable()->setStyle(SkPaint::kFill_Style);
1235 }
1236
1237 SkMatrix matrix;
1238 matrix.setConcat(*fMatrix, prematrix);
1239
1240 if (clipped_out(matrix, *fRC, bitmap.width(), bitmap.height())) {
1241 return;
1242 }
1243
1244 if (bitmap.colorType() != kAlpha_8_SkColorType
1245 && SkTreatAsSprite(matrix, bitmap.dimensions(), *paint)) {
1246 //
1247 // It is safe to call lock pixels now, since we know the matrix is
1248 // (more or less) identity.
1249 //
1250 SkPixmap pmap;
1251 if (!bitmap.peekPixels(&pmap)) {
1252 return;
1253 }
1254 int ix = SkScalarRoundToInt(matrix.getTranslateX());
1255 int iy = SkScalarRoundToInt(matrix.getTranslateY());
1256 if (clipHandlesSprite(*fRC, ix, iy, pmap)) {
1257 SkSTArenaAlloc<kSkBlitterContextSize> allocator;
1258 // blitter will be owned by the allocator.
1259 SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, *paint, pmap, ix, iy, &allocator);
1260 if (blitter) {
1261 SkScan::FillIRect(SkIRect::MakeXYWH(ix, iy, pmap.width(), pmap.height()),
1262 *fRC, blitter);
1263 return;
1264 }
1265 // if !blitter, then we fall-through to the slower case
1266 }
1267 }
1268
1269 // now make a temp draw on the stack, and use it
1270 //
1271 SkDraw draw(*this);
1272 draw.fMatrix = &matrix;
1273
1274 if (bitmap.colorType() == kAlpha_8_SkColorType && !paint->getColorFilter()) {
1275 draw.drawBitmapAsMask(bitmap, *paint);
1276 } else {
1277 SkPaint paintWithShader = make_paint_with_image(*paint, bitmap);
1278 const SkRect srcBounds = SkRect::MakeIWH(bitmap.width(), bitmap.height());
1279 if (dstBounds) {
1280 this->drawRect(srcBounds, paintWithShader, &prematrix, dstBounds);
1281 } else {
1282 draw.drawRect(srcBounds, paintWithShader);
1283 }
1284 }
1285 }
1286
drawSprite(const SkBitmap & bitmap,int x,int y,const SkPaint & origPaint) const1287 void SkDraw::drawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint& origPaint) const {
1288 SkDEBUGCODE(this->validate();)
1289
1290 // nothing to draw
1291 if (fRC->isEmpty() ||
1292 bitmap.width() == 0 || bitmap.height() == 0 ||
1293 bitmap.colorType() == kUnknown_SkColorType) {
1294 return;
1295 }
1296
1297 const SkIRect bounds = SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height());
1298
1299 if (fRC->quickReject(bounds)) {
1300 return; // nothing to draw
1301 }
1302
1303 SkPaint paint(origPaint);
1304 paint.setStyle(SkPaint::kFill_Style);
1305
1306 SkPixmap pmap;
1307 if (!bitmap.peekPixels(&pmap)) {
1308 return;
1309 }
1310
1311 if (nullptr == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
1312 // blitter will be owned by the allocator.
1313 SkSTArenaAlloc<kSkBlitterContextSize> allocator;
1314 SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator);
1315 if (blitter) {
1316 SkScan::FillIRect(bounds, *fRC, blitter);
1317 return;
1318 }
1319 }
1320
1321 SkMatrix matrix;
1322 SkRect r;
1323
1324 // get a scalar version of our rect
1325 r.set(bounds);
1326
1327 // create shader with offset
1328 matrix.setTranslate(r.fLeft, r.fTop);
1329 SkPaint paintWithShader = make_paint_with_image(paint, bitmap, &matrix);
1330 SkDraw draw(*this);
1331 matrix.reset();
1332 draw.fMatrix = &matrix;
1333 // call ourself with a rect
1334 // is this OK if paint has a rasterizer?
1335 draw.drawRect(r, paintWithShader);
1336 }
1337
1338 ///////////////////////////////////////////////////////////////////////////////
1339
1340 #include "SkPaintPriv.h"
1341 #include "SkScalerContext.h"
1342 #include "SkGlyphCache.h"
1343 #include "SkTextToPathIter.h"
1344 #include "SkUtils.h"
1345
ShouldDrawTextAsPaths(const SkPaint & paint,const SkMatrix & ctm)1346 bool SkDraw::ShouldDrawTextAsPaths(const SkPaint& paint, const SkMatrix& ctm) {
1347 // hairline glyphs are fast enough so we don't need to cache them
1348 if (SkPaint::kStroke_Style == paint.getStyle() && 0 == paint.getStrokeWidth()) {
1349 return true;
1350 }
1351
1352 // we don't cache perspective
1353 if (ctm.hasPerspective()) {
1354 return true;
1355 }
1356
1357 SkMatrix textM;
1358 SkPaintPriv::MakeTextMatrix(&textM, paint);
1359 return SkPaint::TooBigToUseCache(ctm, textM);
1360 }
1361
drawText_asPaths(const char text[],size_t byteLength,SkScalar x,SkScalar y,const SkPaint & paint) const1362 void SkDraw::drawText_asPaths(const char text[], size_t byteLength, SkScalar x, SkScalar y,
1363 const SkPaint& paint) const {
1364 SkDEBUGCODE(this->validate();)
1365
1366 SkTextToPathIter iter(text, byteLength, paint, true);
1367
1368 SkMatrix matrix;
1369 matrix.setScale(iter.getPathScale(), iter.getPathScale());
1370 matrix.postTranslate(x, y);
1371
1372 const SkPath* iterPath;
1373 SkScalar xpos, prevXPos = 0;
1374
1375 while (iter.next(&iterPath, &xpos)) {
1376 matrix.postTranslate(xpos - prevXPos, 0);
1377 if (iterPath) {
1378 this->drawPath(*iterPath, iter.getPaint(), &matrix, false);
1379 }
1380 prevXPos = xpos;
1381 }
1382 }
1383
1384 // disable warning : local variable used without having been initialized
1385 #if defined _WIN32
1386 #pragma warning ( push )
1387 #pragma warning ( disable : 4701 )
1388 #endif
1389
1390 ////////////////////////////////////////////////////////////////////////////////////////////////////
1391
1392 class DrawOneGlyph {
1393 public:
DrawOneGlyph(const SkDraw & draw,const SkPaint & paint,SkGlyphCache * cache,SkBlitter * blitter)1394 DrawOneGlyph(const SkDraw& draw, const SkPaint& paint, SkGlyphCache* cache, SkBlitter* blitter)
1395 : fUseRegionToDraw(UsingRegionToDraw(draw.fRC))
1396 , fGlyphCache(cache)
1397 , fBlitter(blitter)
1398 , fClip(fUseRegionToDraw ? &draw.fRC->bwRgn() : nullptr)
1399 , fDraw(draw)
1400 , fPaint(paint)
1401 , fClipBounds(PickClipBounds(draw)) { }
1402
operator ()(const SkGlyph & glyph,SkPoint position,SkPoint rounding)1403 void operator()(const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
1404 position += rounding;
1405 // Prevent glyphs from being drawn outside of or straddling the edge of device space.
1406 // Comparisons written a little weirdly so that NaN coordinates are treated safely.
1407 auto gt = [](float a, int b) { return !(a <= (float)b); };
1408 auto lt = [](float a, int b) { return !(a >= (float)b); };
1409 if (gt(position.fX, INT_MAX - (INT16_MAX + UINT16_MAX)) ||
1410 lt(position.fX, INT_MIN - (INT16_MIN + 0 /*UINT16_MIN*/)) ||
1411 gt(position.fY, INT_MAX - (INT16_MAX + UINT16_MAX)) ||
1412 lt(position.fY, INT_MIN - (INT16_MIN + 0 /*UINT16_MIN*/))) {
1413 return;
1414 }
1415
1416 int left = SkScalarFloorToInt(position.fX);
1417 int top = SkScalarFloorToInt(position.fY);
1418 SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
1419
1420 left += glyph.fLeft;
1421 top += glyph.fTop;
1422
1423 int right = left + glyph.fWidth;
1424 int bottom = top + glyph.fHeight;
1425
1426 SkMask mask;
1427 mask.fBounds.set(left, top, right, bottom);
1428 SkASSERT(!mask.fBounds.isEmpty());
1429
1430 if (fUseRegionToDraw) {
1431 SkRegion::Cliperator clipper(*fClip, mask.fBounds);
1432
1433 if (!clipper.done() && this->getImageData(glyph, &mask)) {
1434 const SkIRect& cr = clipper.rect();
1435 do {
1436 this->blitMask(mask, cr);
1437 clipper.next();
1438 } while (!clipper.done());
1439 }
1440 } else {
1441 SkIRect storage;
1442 SkIRect* bounds = &mask.fBounds;
1443
1444 // this extra test is worth it, assuming that most of the time it succeeds
1445 // since we can avoid writing to storage
1446 if (!fClipBounds.containsNoEmptyCheck(mask.fBounds)) {
1447 if (!storage.intersectNoEmptyCheck(mask.fBounds, fClipBounds))
1448 return;
1449 bounds = &storage;
1450 }
1451
1452 if (this->getImageData(glyph, &mask)) {
1453 this->blitMask(mask, *bounds);
1454 }
1455 }
1456 }
1457
1458 private:
UsingRegionToDraw(const SkRasterClip * rClip)1459 static bool UsingRegionToDraw(const SkRasterClip* rClip) {
1460 return rClip->isBW() && !rClip->isRect();
1461 }
1462
PickClipBounds(const SkDraw & draw)1463 static SkIRect PickClipBounds(const SkDraw& draw) {
1464 const SkRasterClip& rasterClip = *draw.fRC;
1465
1466 if (rasterClip.isBW()) {
1467 return rasterClip.bwRgn().getBounds();
1468 } else {
1469 return rasterClip.aaRgn().getBounds();
1470 }
1471 }
1472
getImageData(const SkGlyph & glyph,SkMask * mask)1473 bool getImageData(const SkGlyph& glyph, SkMask* mask) {
1474 uint8_t* bits = (uint8_t*)(fGlyphCache->findImage(glyph));
1475 if (nullptr == bits) {
1476 return false; // can't rasterize glyph
1477 }
1478 mask->fImage = bits;
1479 mask->fRowBytes = glyph.rowBytes();
1480 mask->fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
1481 return true;
1482 }
1483
blitMask(const SkMask & mask,const SkIRect & clip) const1484 void blitMask(const SkMask& mask, const SkIRect& clip) const {
1485 if (SkMask::kARGB32_Format == mask.fFormat) {
1486 SkBitmap bm;
1487 bm.installPixels(
1488 SkImageInfo::MakeN32Premul(mask.fBounds.width(), mask.fBounds.height()),
1489 (SkPMColor*)mask.fImage, mask.fRowBytes);
1490
1491 fDraw.drawSprite(bm, mask.fBounds.x(), mask.fBounds.y(), fPaint);
1492 } else {
1493 fBlitter->blitMask(mask, clip);
1494 }
1495 }
1496
1497 const bool fUseRegionToDraw;
1498 SkGlyphCache * const fGlyphCache;
1499 SkBlitter * const fBlitter;
1500 const SkRegion* const fClip;
1501 const SkDraw& fDraw;
1502 const SkPaint& fPaint;
1503 const SkIRect fClipBounds;
1504 };
1505
1506 ////////////////////////////////////////////////////////////////////////////////////////////////////
1507
scalerContextFlags() const1508 uint32_t SkDraw::scalerContextFlags() const {
1509 uint32_t flags = SkPaint::kBoostContrast_ScalerContextFlag;
1510 if (!fDst.colorSpace()) {
1511 flags |= SkPaint::kFakeGamma_ScalerContextFlag;
1512 }
1513 return flags;
1514 }
1515
drawText(const char text[],size_t byteLength,SkScalar x,SkScalar y,const SkPaint & paint,const SkSurfaceProps * props) const1516 void SkDraw::drawText(const char text[], size_t byteLength, SkScalar x, SkScalar y,
1517 const SkPaint& paint, const SkSurfaceProps* props) const {
1518 SkASSERT(byteLength == 0 || text != nullptr);
1519
1520 SkDEBUGCODE(this->validate();)
1521
1522 // nothing to draw
1523 if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
1524 return;
1525 }
1526
1527 // SkScalarRec doesn't currently have a way of representing hairline stroke and
1528 // will fill if its frame-width is 0.
1529 if (ShouldDrawTextAsPaths(paint, *fMatrix)) {
1530 this->drawText_asPaths(text, byteLength, x, y, paint);
1531 return;
1532 }
1533
1534 SkAutoGlyphCache cache(paint, props, this->scalerContextFlags(), fMatrix);
1535
1536 // The Blitter Choose needs to be live while using the blitter below.
1537 SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
1538 SkAAClipBlitterWrapper wrapper(*fRC, blitterChooser.get());
1539 DrawOneGlyph drawOneGlyph(*this, paint, cache.get(), wrapper.getBlitter());
1540
1541 SkFindAndPlaceGlyph::ProcessText(
1542 paint.getTextEncoding(), text, byteLength,
1543 {x, y}, *fMatrix, paint.getTextAlign(), cache.get(), drawOneGlyph);
1544 }
1545
1546 //////////////////////////////////////////////////////////////////////////////
1547
drawPosText_asPaths(const char text[],size_t byteLength,const SkScalar pos[],int scalarsPerPosition,const SkPoint & offset,const SkPaint & origPaint,const SkSurfaceProps * props) const1548 void SkDraw::drawPosText_asPaths(const char text[], size_t byteLength, const SkScalar pos[],
1549 int scalarsPerPosition, const SkPoint& offset,
1550 const SkPaint& origPaint, const SkSurfaceProps* props) const {
1551 // setup our std paint, in hopes of getting hits in the cache
1552 SkPaint paint(origPaint);
1553 SkScalar matrixScale = paint.setupForAsPaths();
1554
1555 SkMatrix matrix;
1556 matrix.setScale(matrixScale, matrixScale);
1557
1558 // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache.
1559 paint.setStyle(SkPaint::kFill_Style);
1560 paint.setPathEffect(nullptr);
1561
1562 SkPaint::GlyphCacheProc glyphCacheProc = SkPaint::GetGlyphCacheProc(paint.getTextEncoding(),
1563 paint.isDevKernText(),
1564 true);
1565 SkAutoGlyphCache cache(paint, props, this->scalerContextFlags(), nullptr);
1566
1567 const char* stop = text + byteLength;
1568 SkTextAlignProc alignProc(paint.getTextAlign());
1569 SkTextMapStateProc tmsProc(SkMatrix::I(), offset, scalarsPerPosition);
1570
1571 // Now restore the original settings, so we "draw" with whatever style/stroking.
1572 paint.setStyle(origPaint.getStyle());
1573 paint.setPathEffect(origPaint.refPathEffect());
1574
1575 while (text < stop) {
1576 const SkGlyph& glyph = glyphCacheProc(cache.get(), &text);
1577 if (glyph.fWidth) {
1578 const SkPath* path = cache->findPath(glyph);
1579 if (path) {
1580 SkPoint tmsLoc;
1581 tmsProc(pos, &tmsLoc);
1582 SkPoint loc;
1583 alignProc(tmsLoc, glyph, &loc);
1584
1585 matrix[SkMatrix::kMTransX] = loc.fX;
1586 matrix[SkMatrix::kMTransY] = loc.fY;
1587 this->drawPath(*path, paint, &matrix, false);
1588 }
1589 }
1590 pos += scalarsPerPosition;
1591 }
1592 }
1593
drawPosText(const char text[],size_t byteLength,const SkScalar pos[],int scalarsPerPosition,const SkPoint & offset,const SkPaint & paint,const SkSurfaceProps * props) const1594 void SkDraw::drawPosText(const char text[], size_t byteLength, const SkScalar pos[],
1595 int scalarsPerPosition, const SkPoint& offset, const SkPaint& paint,
1596 const SkSurfaceProps* props) const {
1597 SkASSERT(byteLength == 0 || text != nullptr);
1598 SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
1599
1600 SkDEBUGCODE(this->validate();)
1601
1602 // nothing to draw
1603 if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
1604 return;
1605 }
1606
1607 if (ShouldDrawTextAsPaths(paint, *fMatrix)) {
1608 this->drawPosText_asPaths(text, byteLength, pos, scalarsPerPosition, offset, paint, props);
1609 return;
1610 }
1611
1612 SkAutoGlyphCache cache(paint, props, this->scalerContextFlags(), fMatrix);
1613
1614 // The Blitter Choose needs to be live while using the blitter below.
1615 SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
1616 SkAAClipBlitterWrapper wrapper(*fRC, blitterChooser.get());
1617 DrawOneGlyph drawOneGlyph(*this, paint, cache.get(), wrapper.getBlitter());
1618 SkPaint::Align textAlignment = paint.getTextAlign();
1619
1620 SkFindAndPlaceGlyph::ProcessPosText(
1621 paint.getTextEncoding(), text, byteLength,
1622 offset, *fMatrix, pos, scalarsPerPosition, textAlignment, cache.get(), drawOneGlyph);
1623 }
1624
1625 #if defined _WIN32
1626 #pragma warning ( pop )
1627 #endif
1628
1629 ////////////////////////////////////////////////////////////////////////////////////////////////
1630
1631 #ifdef SK_DEBUG
1632
validate() const1633 void SkDraw::validate() const {
1634 SkASSERT(fMatrix != nullptr);
1635 SkASSERT(fRC != nullptr);
1636
1637 const SkIRect& cr = fRC->getBounds();
1638 SkIRect br;
1639
1640 br.set(0, 0, fDst.width(), fDst.height());
1641 SkASSERT(cr.isEmpty() || br.contains(cr));
1642 }
1643
1644 #endif
1645
1646 ////////////////////////////////////////////////////////////////////////////////////////////////
1647
1648 #include "SkPath.h"
1649 #include "SkDraw.h"
1650 #include "SkRegion.h"
1651 #include "SkBlitter.h"
1652
compute_bounds(const SkPath & devPath,const SkIRect * clipBounds,const SkMaskFilter * filter,const SkMatrix * filterMatrix,SkIRect * bounds)1653 static bool compute_bounds(const SkPath& devPath, const SkIRect* clipBounds,
1654 const SkMaskFilter* filter, const SkMatrix* filterMatrix,
1655 SkIRect* bounds) {
1656 if (devPath.isEmpty()) {
1657 return false;
1658 }
1659
1660 // init our bounds from the path
1661 *bounds = devPath.getBounds().makeOutset(SK_ScalarHalf, SK_ScalarHalf).roundOut();
1662
1663 SkIPoint margin = SkIPoint::Make(0, 0);
1664 if (filter) {
1665 SkASSERT(filterMatrix);
1666
1667 SkMask srcM, dstM;
1668
1669 srcM.fBounds = *bounds;
1670 srcM.fFormat = SkMask::kA8_Format;
1671 if (!filter->filterMask(&dstM, srcM, *filterMatrix, &margin)) {
1672 return false;
1673 }
1674 }
1675
1676 // (possibly) trim the bounds to reflect the clip
1677 // (plus whatever slop the filter needs)
1678 if (clipBounds) {
1679 // Ugh. Guard against gigantic margins from wacky filters. Without this
1680 // check we can request arbitrary amounts of slop beyond our visible
1681 // clip, and bring down the renderer (at least on finite RAM machines
1682 // like handsets, etc.). Need to balance this invented value between
1683 // quality of large filters like blurs, and the corresponding memory
1684 // requests.
1685 static const int MAX_MARGIN = 128;
1686 if (!bounds->intersect(clipBounds->makeOutset(SkMin32(margin.fX, MAX_MARGIN),
1687 SkMin32(margin.fY, MAX_MARGIN)))) {
1688 return false;
1689 }
1690 }
1691
1692 return true;
1693 }
1694
draw_into_mask(const SkMask & mask,const SkPath & devPath,SkStrokeRec::InitStyle style)1695 static void draw_into_mask(const SkMask& mask, const SkPath& devPath,
1696 SkStrokeRec::InitStyle style) {
1697 SkDraw draw;
1698 if (!draw.fDst.reset(mask)) {
1699 return;
1700 }
1701
1702 SkRasterClip clip;
1703 SkMatrix matrix;
1704 SkPaint paint;
1705
1706 clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
1707 matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
1708 -SkIntToScalar(mask.fBounds.fTop));
1709
1710 draw.fRC = &clip;
1711 draw.fMatrix = &matrix;
1712 paint.setAntiAlias(true);
1713 switch (style) {
1714 case SkStrokeRec::kHairline_InitStyle:
1715 SkASSERT(!paint.getStrokeWidth());
1716 paint.setStyle(SkPaint::kStroke_Style);
1717 break;
1718 case SkStrokeRec::kFill_InitStyle:
1719 SkASSERT(paint.getStyle() == SkPaint::kFill_Style);
1720 break;
1721
1722 }
1723 draw.drawPath(devPath, paint);
1724 }
1725
DrawToMask(const SkPath & devPath,const SkIRect * clipBounds,const SkMaskFilter * filter,const SkMatrix * filterMatrix,SkMask * mask,SkMask::CreateMode mode,SkStrokeRec::InitStyle style)1726 bool SkDraw::DrawToMask(const SkPath& devPath, const SkIRect* clipBounds,
1727 const SkMaskFilter* filter, const SkMatrix* filterMatrix,
1728 SkMask* mask, SkMask::CreateMode mode,
1729 SkStrokeRec::InitStyle style) {
1730 if (SkMask::kJustRenderImage_CreateMode != mode) {
1731 if (!compute_bounds(devPath, clipBounds, filter, filterMatrix, &mask->fBounds))
1732 return false;
1733 }
1734
1735 if (SkMask::kComputeBoundsAndRenderImage_CreateMode == mode) {
1736 mask->fFormat = SkMask::kA8_Format;
1737 mask->fRowBytes = mask->fBounds.width();
1738 size_t size = mask->computeImageSize();
1739 if (0 == size) {
1740 // we're too big to allocate the mask, abort
1741 return false;
1742 }
1743 mask->fImage = SkMask::AllocImage(size);
1744 memset(mask->fImage, 0, mask->computeImageSize());
1745 }
1746
1747 if (SkMask::kJustComputeBounds_CreateMode != mode) {
1748 draw_into_mask(*mask, devPath, style);
1749 }
1750
1751 return true;
1752 }
1753