AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "Revert "speed up A8 by creating a new entry-point in SkDraw that blits the path's coverage directly into an A8 target, regardless of the previous pixel values.""

Browse Source 
This reverts commit 3c77887b3eb2d32ab668ab4e5f2f9e79103956e8.

BUG=

Review URL: https://codereview.chromium.org/50673005

git-svn-id: http://skia.googlecode.com/svn/trunk@12167 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
reed@google.com 2013-11-07 16:06:53 +00:00
parent c51808445f
commit 126f7f5244
10 changed files with 229 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
bench/CoverageBench.cpp Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkBenchmark.h"
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkColorPriv.h"
#include "SkDraw.h"
#include "SkMatrix.h"
#include "SkPath.h"
#include "SkRasterClip.h"
class DrawPathBench : public SkBenchmark {
SkPaint fPaint;
SkString fName;
SkPath fPath;
SkRasterClip fRC;
SkBitmap fBitmap;
SkMatrix fIdentity;
SkDraw fDraw;
bool fDrawCoverage;
public:
DrawPathBench(bool drawCoverage) : fDrawCoverage(drawCoverage) {
fPaint.setAntiAlias(true);
fName.printf("draw_coverage_%s", drawCoverage ? "true" : "false");
fPath.moveTo(0, 0);
fPath.quadTo(500, 0, 500, 500);
fPath.quadTo(250, 0, 0, 500);
fBitmap.setConfig(SkBitmap::kA8_Config, 500, 500);
fBitmap.allocPixels();
fIdentity.setIdentity();
fRC.setRect(fPath.getBounds().round());
fDraw.fBitmap = &fBitmap;
fDraw.fMatrix = &fIdentity;
fDraw.fClip = &fRC.bwRgn();
fDraw.fRC = &fRC;
}
protected:
virtual const char* onGetName() SK_OVERRIDE {
return fName.c_str();
}
virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
if (fDrawCoverage) {
for (int i = 0; i < this->getLoops(); ++i) {
fDraw.drawPathCoverage(fPath, fPaint);
}
} else {
for (int i = 0; i < this->getLoops(); ++i) {
fDraw.drawPath(fPath, fPaint);
}
}
}
private:
typedef SkBenchmark INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
DEF_BENCH( return new DrawPathBench(false) )
DEF_BENCH( return new DrawPathBench(true) )

1
gyp/bench.gypi
View File

@ -19,6 +19,7 @@
'../bench/ChromeBench.cpp',
'../bench/CmapBench.cpp',
'../bench/ColorFilterBench.cpp',
'../bench/CoverageBench.cpp',
'../bench/DashBench.cpp',
'../bench/DecodeBench.cpp',
'../bench/DeferredCanvasBench.cpp',

24
include/core/SkDraw.h
View File

@ -43,8 +43,15 @@ public:
* affect the geometry/rasterization, then the pre matrix can just be
* pre-concated with the current matrix.
*/
void drawPath(const SkPath& srcPath, const SkPaint&,
const SkMatrix* prePathMatrix, bool pathIsMutable) const;
void drawPath(const SkPath& path, const SkPaint& paint,
const SkMatrix* prePathMatrix, bool pathIsMutable) const {
this->drawPath(path, paint, prePathMatrix, pathIsMutable, false);
}
void drawPath(const SkPath& path, const SkPaint& paint) const {
this->drawPath(path, paint, NULL, false, false);
}
void drawBitmap(const SkBitmap&, const SkMatrix&, const SkPaint&) const;
void drawSprite(const SkBitmap&, int x, int y, const SkPaint&) const;
void drawText(const char text[], size_t byteLength, SkScalar x,
@ -65,8 +72,14 @@ public:
const uint16_t indices[], int ptCount,
const SkPaint& paint) const;
void drawPath(const SkPath& src, const SkPaint& paint) const {
this->drawPath(src, paint, NULL, false);
/**
* Overwrite the target with the path's coverage (i.e. its mask).
* Will overwrite the entire device, so it need not be zero'd first.
*
* Only device A8 is supported right now.
*/
void drawPathCoverage(const SkPath& src, const SkPaint& paint) const {
this->drawPath(src, paint, NULL, false, true);
}
/** Helper function that creates a mask from a path and an optional maskfilter.
@ -107,6 +120,9 @@ private:
void drawDevMask(const SkMask& mask, const SkPaint&) const;
void drawBitmapAsMask(const SkBitmap&, const SkPaint&) const;
void drawPath(const SkPath&, const SkPaint&, const SkMatrix* preMatrix,
bool pathIsMutable, bool drawCoverage) const;
/**
* Return the current clip bounds, in local coordinates, with slop to account
* for antialiasing or hairlines (i.e. device-bounds outset by 1, and then

11
include/core/SkRect.h
View File

@ -730,7 +730,7 @@ struct SK_API SkRect {
/**
* Set the dst rectangle by rounding this rectangle's coordinates to their
* nearest integer values using SkScalarRound.
* nearest integer values using SkScalarRoundToInt.
*/
void round(SkIRect* dst) const {
SkASSERT(dst);
@ -772,6 +772,15 @@ struct SK_API SkRect {
SkScalarFloorToInt(fRight), SkScalarFloorToInt(fBottom));
}
/**
* Return a new SkIRect which is contains the rounded coordinates of this
* rect using SkScalarRoundToInt.
*/
SkIRect round() const {
SkIRect ir;
this->round(&ir);
return ir;
}
/**
* Swap top/bottom or left/right if there are flipped (i.e. if width()

14
src/core/SkBlitter.cpp
View File

@ -850,14 +850,16 @@ static XferInterp interpret_xfermode(const SkPaint& paint, SkXfermode* xfer,
SkBlitter* SkBlitter::Choose(const SkBitmap& device,
const SkMatrix& matrix,
const SkPaint& origPaint,
void* storage, size_t storageSize) {
void* storage, size_t storageSize,
bool drawCoverage) {
SkASSERT(storageSize == 0 || storage != NULL);
SkBlitter* blitter = NULL;
// which check, in case we're being called by a client with a dummy device
// (e.g. they have a bounder that always aborts the draw)
if (SkBitmap::kNo_Config == device.config()) {
if (SkBitmap::kNo_Config == device.config() ||
(drawCoverage && (SkBitmap::kA8_Config != device.config()))) {
SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
return blitter;
}
@ -940,6 +942,7 @@ SkBlitter* SkBlitter::Choose(const SkBitmap& device,
return blitter;
}
switch (device.config()) {
case SkBitmap::kA1_Config:
SK_PLACEMENT_NEW_ARGS(blitter, SkA1_Blitter,
@ -947,7 +950,12 @@ SkBlitter* SkBlitter::Choose(const SkBitmap& device,
break;
case SkBitmap::kA8_Config:
if (shader) {
if (drawCoverage) {
SkASSERT(NULL == shader);
SkASSERT(NULL == paint->getXfermode());
SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Coverage_Blitter,
storage, storageSize, (device, *paint));
} else if (shader) {
SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Shader_Blitter,
storage, storageSize, (device, *paint));
} else {

3
src/core/SkBlitter.h
View File

@ -76,7 +76,8 @@ public:
static SkBlitter* Choose(const SkBitmap& device,
const SkMatrix& matrix,
const SkPaint& paint,
void* storage, size_t storageSize);
void* storage, size_t storageSize,
bool drawCoverage = false);
static SkBlitter* ChooseSprite(const SkBitmap& device,
const SkPaint&,

90
src/core/SkBlitter_A8.cpp
View File

@ -347,3 +347,93 @@ void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
alpha += mask.fRowBytes;
}
}
///////////////////////////////////////////////////////////////////////////////
#define SK_A8_COVERAGE_BLIT_SKIP_ZEROS
SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkBitmap& device,
const SkPaint& paint) : SkRasterBlitter(device) {
SkASSERT(NULL == paint.getShader());
SkASSERT(NULL == paint.getXfermode());
SkASSERT(NULL == paint.getColorFilter());
}
void SkA8_Coverage_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
const int16_t runs[]) {
SkASSERT(0 == x);
uint8_t* device = fDevice.getAddr8(x, y);
SkDEBUGCODE(int totalCount = 0;)
for (;;) {
int count = runs[0];
SkASSERT(count >= 0);
if (count == 0) {
return;
}
#ifdef SK_A8_COVERAGE_BLIT_SKIP_ZEROS
if (antialias[0])
#endif
{
memset(device, antialias[0], count);
}
runs += count;
antialias += count;
device += count;
SkDEBUGCODE(totalCount += count;)
}
SkASSERT(fDevice.width() == totalCount);
}
void SkA8_Coverage_Blitter::blitH(int x, int y, int width) {
memset(fDevice.getAddr8(x, y), 0xFF, width);
}
void SkA8_Coverage_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
#ifdef SK_A8_COVERAGE_BLIT_SKIP_ZEROS
if (0 == alpha) {
return;
}
#endif
uint8_t* dst = fDevice.getAddr8(x, y);
const size_t dstRB = fDevice.rowBytes();
while (--height >= 0) {
*dst = alpha;
dst += dstRB;
}
}
void SkA8_Coverage_Blitter::blitRect(int x, int y, int width, int height) {
uint8_t* dst = fDevice.getAddr8(x, y);
const size_t dstRB = fDevice.rowBytes();
while (--height >= 0) {
memset(dst, 0xFF, width);
dst += dstRB;
}
}
void SkA8_Coverage_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
SkASSERT(SkMask::kA8_Format == mask.fFormat);
int x = clip.fLeft;
int y = clip.fTop;
int width = clip.width();
int height = clip.height();
uint8_t* dst = fDevice.getAddr8(x, y);
const uint8_t* src = mask.getAddr8(x, y);
const size_t srcRB = mask.fRowBytes;
const size_t dstRB = fDevice.rowBytes();
while (--height >= 0) {
memcpy(dst, src, width);
dst += dstRB;
src += srcRB;
}
}
const SkBitmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) {
return NULL;
}

11
src/core/SkCoreBlitters.h
View File

@ -40,6 +40,17 @@ private:
///////////////////////////////////////////////////////////////////////////////
class SkA8_Coverage_Blitter : public SkRasterBlitter {
public:
SkA8_Coverage_Blitter(const SkBitmap& device, const SkPaint& paint);
virtual void blitH(int x, int y, int width) SK_OVERRIDE;
virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) SK_OVERRIDE;
virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
virtual void blitMask(const SkMask&, const SkIRect&) SK_OVERRIDE;
virtual const SkBitmap* justAnOpaqueColor(uint32_t*) SK_OVERRIDE;
};
class SkA8_Blitter : public SkRasterBlitter {
public:
SkA8_Blitter(const SkBitmap& device, const SkPaint& paint);

9
src/core/SkDraw.cpp
View File

@ -59,9 +59,9 @@ public:
fBlitter = NULL;
}
SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix,
const SkPaint& paint) {
const SkPaint& paint, bool drawCoverage = false) {
fBlitter = SkBlitter::Choose(device, matrix, paint,
fStorage, sizeof(fStorage));
fStorage, sizeof(fStorage), drawCoverage);
}
~SkAutoBlitterChoose();
@ -1023,7 +1023,8 @@ bool SkDrawTreatAsHairline(const SkPaint& paint, const SkMatrix& matrix,
}
void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
const SkMatrix* prePathMatrix, bool pathIsMutable) const {
const SkMatrix* prePathMatrix, bool pathIsMutable,
bool drawCoverage) const {
SkDEBUGCODE(this->validate();)
// nothing to draw
@ -1112,7 +1113,7 @@ void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
// transform the path into device space
pathPtr->transform(*matrix, devPathPtr);
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint);
SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint, drawCoverage);
if (paint->getMaskFilter()) {
SkPaint::Style style = doFill ? SkPaint::kFill_Style :

16
src/gpu/GrSWMaskHelper.cpp
View File

@ -73,16 +73,16 @@ void GrSWMaskHelper::draw(const SkPath& path, const SkStrokeRec& stroke, SkRegio
paint.setStrokeWidth(stroke.getWidth());
}
}
SkXfermode* mode = SkXfermode::Create(op_to_mode(op));
paint.setXfermode(mode);
paint.setAntiAlias(antiAlias);
paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
fDraw.drawPath(path, paint);
SkSafeUnref(mode);
if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
SkASSERT(0xFF == paint.getAlpha());
fDraw.drawPathCoverage(path, paint);
} else {
paint.setXfermodeMode(op_to_mode(op));
paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
fDraw.drawPath(path, paint);
}
}
bool GrSWMaskHelper::init(const SkIRect& resultBounds,