From: reed@google.com Date: Wed, 13 Apr 2011 17:44:24 +0000 (+0000) Subject: speed up 2-point-radial gradients by 9x, using float instead of fixed X-Git-Tag: accepted/tizen/5.0/unified/20181102.025319~18683 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=84e9c0801f9a2da1ca12a38250a95fd393caded1;p=platform%2Fupstream%2FlibSkiaSharp.git speed up 2-point-radial gradients by 9x, using float instead of fixed git-svn-id: http://skia.googlecode.com/svn/trunk@1118 2bbb7eff-a529-9590-31e7-b0007b416f81 --- diff --git a/bench/GradientBench.cpp b/bench/GradientBench.cpp new file mode 100644 index 0000000..6a6e47d --- /dev/null +++ b/bench/GradientBench.cpp @@ -0,0 +1,151 @@ +#include "SkBenchmark.h" +#include "SkBitmap.h" +#include "SkCanvas.h" +#include "SkColorPriv.h" +#include "SkGradientShader.h" +#include "SkPaint.h" +#include "SkShader.h" +#include "SkString.h" +#include "SkUnitMapper.h" + +struct GradData { + int fCount; + const SkColor* fColors; + const SkScalar* fPos; +}; + +static const SkColor gColors[] = { + SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK +}; +static const SkScalar gPos0[] = { 0, SK_Scalar1 }; +static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 }; +static const SkScalar gPos2[] = { + 0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1 +}; + +static const GradData gGradData[] = { + { 2, gColors, NULL }, + { 2, gColors, gPos0 }, + { 2, gColors, gPos1 }, + { 5, gColors, NULL }, + { 5, gColors, gPos2 } +}; + +static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data, + SkShader::TileMode tm, SkUnitMapper* mapper) { + return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, + data.fCount, tm, mapper); +} + +static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data, + SkShader::TileMode tm, SkUnitMapper* mapper) { + SkPoint center; + center.set(SkScalarAve(pts[0].fX, pts[1].fX), + SkScalarAve(pts[0].fY, pts[1].fY)); + return SkGradientShader::CreateRadial(center, center.fX, data.fColors, + data.fPos, data.fCount, tm, mapper); +} + +static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data, + SkShader::TileMode tm, SkUnitMapper* mapper) { + SkPoint center; + center.set(SkScalarAve(pts[0].fX, pts[1].fX), + SkScalarAve(pts[0].fY, pts[1].fY)); + return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors, + data.fPos, data.fCount, mapper); +} + +static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data, + SkShader::TileMode tm, SkUnitMapper* mapper) { + SkPoint center0, center1; + center0.set(SkScalarAve(pts[0].fX, pts[1].fX), + SkScalarAve(pts[0].fY, pts[1].fY)); + center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5), + SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4)); + return SkGradientShader::CreateTwoPointRadial( + center1, (pts[1].fX - pts[0].fX) / 7, + center0, (pts[1].fX - pts[0].fX) / 2, + data.fColors, data.fPos, data.fCount, tm, mapper); +} + +typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data, + SkShader::TileMode tm, SkUnitMapper* mapper); + +static const struct { + GradMaker fMaker; + const char* fName; + int fRepeat; +} gGrads[] = { + { MakeLinear, "linear", 15 }, + { MakeRadial, "radial", 10 }, + { MakeSweep, "sweep", 1 }, + { Make2Radial, "radial2", 5 }, +}; + +enum GradType { // these must match the order in gGrads + kLinear_GradType, + kRadial_GradType, + kSweep_GradType, + kRadial2_GradType +}; + +/////////////////////////////////////////////////////////////////////////////// + +class GradientBench : public SkBenchmark { + SkString fName; + SkShader* fShader; + int fCount; + enum { + W = 400, + H = 400, + N = 1 + }; +public: + GradientBench(void* param, GradType gt) : INHERITED(param) { + fName.printf("gradient_%s", gGrads[gt].fName); + + const SkPoint pts[2] = { + { 0, 0 }, + { SkIntToScalar(W), SkIntToScalar(H) } + }; + + fCount = N * gGrads[gt].fRepeat; + fShader = gGrads[gt].fMaker(pts, gGradData[0], + SkShader::kClamp_TileMode, NULL); + } + + virtual ~GradientBench() { + fShader->unref(); + } + +protected: + virtual const char* onGetName() { + return fName.c_str(); + } + + virtual void onDraw(SkCanvas* canvas) { + SkPaint paint; + this->setupPaint(&paint); + + paint.setShader(fShader); + + SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) }; + for (int i = 0; i < fCount; i++) { + canvas->drawRect(r, paint); + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +static SkBenchmark* Fact0(void* p) { return new GradientBench(p, kLinear_GradType); } +static SkBenchmark* Fact1(void* p) { return new GradientBench(p, kRadial_GradType); } +static SkBenchmark* Fact2(void* p) { return new GradientBench(p, kSweep_GradType); } +static SkBenchmark* Fact3(void* p) { return new GradientBench(p, kRadial2_GradType); } + +static BenchRegistry gReg0(Fact0); +static BenchRegistry gReg1(Fact1); +static BenchRegistry gReg2(Fact2); +static BenchRegistry gReg3(Fact3); + diff --git a/src/effects/SkGradientShader.cpp b/src/effects/SkGradientShader.cpp index f43cf4b..2a5008d 100644 --- a/src/effects/SkGradientShader.cpp +++ b/src/effects/SkGradientShader.cpp @@ -1361,18 +1361,22 @@ private: */ -static inline SkFixed two_point_radial(SkFixed b, SkFixed fx, SkFixed fy, SkFixed sr2d2, SkFixed foura, SkFixed oneOverTwoA, bool posRoot) { - SkFixed c = SkFixedSquare(fx) + SkFixedSquare(fy) - sr2d2; - SkFixed discrim = SkFixedSquare(b) - SkFixedMul(foura, c); +static inline SkFixed two_point_radial(SkScalar b, SkScalar fx, SkScalar fy, + SkScalar sr2d2, SkScalar foura, + SkScalar oneOverTwoA, bool posRoot) { + SkScalar c = SkScalarSquare(fx) + SkScalarSquare(fy) - sr2d2; + SkScalar discrim = SkScalarSquare(b) - SkScalarMul(foura, c); if (discrim < 0) { discrim = -discrim; } - SkFixed rootDiscrim = SkFixedSqrt(discrim); + SkScalar rootDiscrim = SkScalarSqrt(discrim); + SkScalar result; if (posRoot) { - return SkFixedMul(-b + rootDiscrim, oneOverTwoA); + result = SkScalarMul(-b + rootDiscrim, oneOverTwoA); } else { - return SkFixedMul(-b - rootDiscrim, oneOverTwoA); + result = SkScalarMul(-b - rootDiscrim, oneOverTwoA); } + return SkScalarToFixed(result); } class Two_Point_Radial_Gradient : public Gradient_Shader { @@ -1447,39 +1451,38 @@ public: SkMatrix::MapXYProc dstProc = fDstToIndexProc; TileProc proc = fTileProc; const SkPMColor* cache = this->getCache32(); - SkFixed diffx = SkScalarToFixed(fDiff.fX); - SkFixed diffy = SkScalarToFixed(fDiff.fY); - SkFixed foura = SkScalarToFixed(SkScalarMul(fA, 4)); - SkFixed startRadius = SkScalarToFixed(fStartRadius); - SkFixed sr2D2 = SkScalarToFixed(fSr2D2); - SkFixed oneOverTwoA = SkScalarToFixed(fOneOverTwoA); + + SkScalar foura = fA * 4; bool posRoot = fDiffRadius < 0; if (fDstToIndexClass != kPerspective_MatrixClass) { SkPoint srcPt; dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf, &srcPt); - SkFixed dx, fx = SkScalarToFixed(srcPt.fX); - SkFixed dy, fy = SkScalarToFixed(srcPt.fY); + SkScalar dx, fx = srcPt.fX; + SkScalar dy, fy = srcPt.fY; if (fDstToIndexClass == kFixedStepInX_MatrixClass) { - (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &dx, &dy); + SkFixed fixedX, fixedY; + (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY); + dx = SkFixedToScalar(fixedX); + dy = SkFixedToScalar(fixedY); } else { SkASSERT(fDstToIndexClass == kLinear_MatrixClass); - dx = SkScalarToFixed(fDstToIndex.getScaleX()); - dy = SkScalarToFixed(fDstToIndex.getSkewY()); + dx = fDstToIndex.getScaleX(); + dy = fDstToIndex.getSkewY(); } - SkFixed b = (SkFixedMul(diffx, fx) + - SkFixedMul(diffy, fy) - startRadius) << 1; - SkFixed db = (SkFixedMul(diffx, dx) + - SkFixedMul(diffy, dy)) << 1; + SkScalar b = (SkScalarMul(fDiff.fX, fx) + + SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2; + SkScalar db = (SkScalarMul(fDiff.fX, dx) + + SkScalarMul(fDiff.fY, dy)) * 2; if (proc == clamp_tileproc) { for (; count > 0; --count) { - SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot); + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot); SkFixed index = SkClampMax(t, 0xFFFF); SkASSERT(index <= 0xFFFF); *dstC++ = cache[index >> (16 - kCache32Bits)]; @@ -1491,7 +1494,7 @@ public: else if (proc == mirror_tileproc) { for (; count > 0; --count) { - SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot); + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot); SkFixed index = mirror_tileproc(t); SkASSERT(index <= 0xFFFF); *dstC++ = cache[index >> (16 - kCache32Bits)]; @@ -1504,7 +1507,7 @@ public: { SkASSERT(proc == repeat_tileproc); for (; count > 0; --count) { - SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot); + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot); SkFixed index = repeat_tileproc(t); SkASSERT(index <= 0xFFFF); *dstC++ = cache[index >> (16 - kCache32Bits)]; @@ -1521,11 +1524,11 @@ public: for (; count > 0; --count) { SkPoint srcPt; dstProc(fDstToIndex, dstX, dstY, &srcPt); - SkFixed fx = SkScalarToFixed(srcPt.fX); - SkFixed fy = SkScalarToFixed(srcPt.fY); - SkFixed b = (SkFixedMul(diffx, fx) + - SkFixedMul(diffy, fy) - startRadius) << 1; - SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot); + SkScalar fx = srcPt.fX; + SkScalar fy = srcPt.fY; + SkScalar b = (SkScalarMul(fDiff.fX, fx) + + SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2; + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot); SkFixed index = proc(t); SkASSERT(index <= 0xFFFF); *dstC++ = cache[index >> (16 - kCache32Bits)];