From 14e4d392d4ffa50c0ddf359a426668d1718d7f92 Mon Sep 17 00:00:00 2001 From: mtklein Date: Thu, 23 Oct 2014 14:35:01 -0700 Subject: [PATCH] Revert "Revert of create shaderproc for nofilter-opaque-dx (patchset #7 id:120001 of https://codereview.chromium.org/664783004/)" This reverts commit 430b795cc8a1cdbddd8fdc5511a3a523348937f7 and adds suppressions. BUG=skia: Review URL: https://codereview.chromium.org/673023002 --- bench/BitmapBench.cpp | 35 +++++++++++++++-------- expectations/gm/ignored-tests.txt | 18 ++++++++++++ src/core/SkBitmapProcState.cpp | 59 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 100 insertions(+), 12 deletions(-) diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp index efd6d96..da2e829 100644 --- a/bench/BitmapBench.cpp +++ b/bench/BitmapBench.cpp @@ -75,6 +75,7 @@ class BitmapBench : public Benchmark { const SkAlphaType fAlphaType; const bool fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache const bool fIsVolatile; + const bool fDoScale; SkBitmap fBitmap; SkPaint fPaint; @@ -83,11 +84,12 @@ class BitmapBench : public Benchmark { enum { W = 128 }; enum { H = 128 }; public: - BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate = false, bool isVolatile = false) + BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate, bool isVolatile, bool doScale) : fColorType(ct) , fAlphaType(at) , fForceUpdate(forceUpdate) , fIsVolatile(isVolatile) + , fDoScale(doScale) {} protected: @@ -95,10 +97,15 @@ protected: fName.set("bitmap"); fName.appendf("_%s%s", sk_tool_utils::colortype_name(fColorType), kOpaque_SkAlphaType == fAlphaType ? "" : "_A"); - if (fForceUpdate) + if (fDoScale) { + fName.append("_scale"); + } + if (fForceUpdate) { fName.append("_update"); - if (fIsVolatile) + } + if (fIsVolatile) { fName.append("_volatile"); + } return fName.c_str(); } @@ -125,6 +132,9 @@ protected: } virtual void onDraw(const int loops, SkCanvas* canvas) { + if (fDoScale) { + canvas->scale(.99f, .99f); + } SkIPoint dim = this->getSize(); SkRandom rand; @@ -193,7 +203,7 @@ class FilterBitmapBench : public BitmapBench { public: FilterBitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate, bool isVolitile, uint32_t flags) - : INHERITED(ct, at, forceUpdate, isVolitile) + : INHERITED(ct, at, forceUpdate, isVolitile, false) , fFlags(flags) { } @@ -272,7 +282,7 @@ private: public: SourceAlphaBitmapBench(SourceAlpha alpha, SkColorType ct, bool forceUpdate = false, bool bitmapVolatile = false) - : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, bitmapVolatile) + : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, bitmapVolatile, false) , fSourceAlpha(alpha) { } @@ -349,13 +359,14 @@ private: typedef BitmapBench INHERITED; }; -DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType); ) -DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType); ) -DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType); ) -DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kPremul_SkAlphaType); ) -DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kOpaque_SkAlphaType); ) -DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true); ) -DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false); ) +DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, false); ) +DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, false); ) +DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, true); ) +DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType, false, false, false); ) +DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kPremul_SkAlphaType, false, false, false); ) +DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kOpaque_SkAlphaType, false, false, false); ) +DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true, false); ) +DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false, false); ) // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2 DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag); ) diff --git a/expectations/gm/ignored-tests.txt b/expectations/gm/ignored-tests.txt index 976a2a8..ad1f7a3 100644 --- a/expectations/gm/ignored-tests.txt +++ b/expectations/gm/ignored-tests.txt @@ -58,3 +58,21 @@ dftext megalooper_0x0 megalooper_1x4 megalooper_4x1 + +#mtklein/reed: slight image resize fixes +bitmaprecttest +bitmapshaders +downsamplebitmap_checkerboard_none_512_256 +downsamplebitmap_image_none_mandrill_512.png +downsamplebitmap_text_none_72.00pt +filterbitmap_checkerboard_192_192 +filterbitmap_image_mandrill_128.png +filterbitmap_image_mandrill_256.png +filterbitmap_image_mandrill_512.png +filterbitmap_image_mandrill_64.png +filterbitmap_text_10.00pt +filterbitmap_text_7.00pt +image-surface +scaled_tilemode_bitmap +tilemode_bitmap +verylargebitmap diff --git a/src/core/SkBitmapProcState.cpp b/src/core/SkBitmapProcState.cpp index 2a449d6..b1b50b0 100644 --- a/src/core/SkBitmapProcState.cpp +++ b/src/core/SkBitmapProcState.cpp @@ -30,6 +30,8 @@ extern void SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, extern void Clamp_SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint32_t*, int); #endif +extern void Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const SkBitmapProcState&, int, int, uint32_t*, int); + #define NAME_WRAP(x) x #include "SkBitmapProcState_filter.h" #include "SkBitmapProcState_procs.h" @@ -589,6 +591,8 @@ bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) { } } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clampClamp) { fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc); + } else if (S32_opaque_D32_nofilter_DX == fSampleProc32 && clampClamp) { + fShaderProc32 = Clamp_S32_opaque_D32_nofilter_DX_shaderproc; } if (NULL == fShaderProc32) { @@ -1019,3 +1023,58 @@ int SkBitmapProcState::maxCountForBufferSize(size_t bufferSize) const { return size; } + +/////////////////////// + +void Clamp_S32_opaque_D32_nofilter_DX_shaderproc(const SkBitmapProcState& s, int x, int y, + SkPMColor* SK_RESTRICT dst, int count) { + SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | + SkMatrix::kScale_Mask)) == 0); + + const unsigned maxX = s.fBitmap->width() - 1; + SkFractionalInt fx; + int dstY; + { + SkPoint pt; + s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, SkIntToScalar(y) + SK_ScalarHalf, + &pt); + fx = SkScalarToFractionalInt(pt.fY); + const unsigned maxY = s.fBitmap->height() - 1; + dstY = SkClampMax(SkFractionalIntToInt(fx), maxY); + fx = SkScalarToFractionalInt(pt.fX); + } + + const SkPMColor* SK_RESTRICT src = s.fBitmap->getAddr32(0, dstY); + const SkFractionalInt dx = s.fInvSxFractionalInt; + + // Check if we're safely inside [0...maxX] so no need to clamp each computed index. + // + if ((uint64_t)SkFractionalIntToInt(fx) <= maxX && + (uint64_t)SkFractionalIntToInt(fx + dx * (count - 1)) <= maxX) + { + int count4 = count >> 2; + for (int i = 0; i < count4; ++i) { + SkPMColor src0 = src[SkFractionalIntToInt(fx)]; fx += dx; + SkPMColor src1 = src[SkFractionalIntToInt(fx)]; fx += dx; + SkPMColor src2 = src[SkFractionalIntToInt(fx)]; fx += dx; + SkPMColor src3 = src[SkFractionalIntToInt(fx)]; fx += dx; + dst[0] = src0; + dst[1] = src1; + dst[2] = src2; + dst[3] = src3; + dst += 4; + } + for (int i = (count4 << 2); i < count; ++i) { + unsigned index = SkFractionalIntToInt(fx); + SkASSERT(index <= maxX); + *dst++ = src[index]; + fx += dx; + } + } else { + for (int i = 0; i < count; ++i) { + dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)]; + fx += dx; + } + } +} + -- 2.7.4