| /* |
| * Copyright 2016 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "Benchmark.h" |
| #include "SkRasterPipeline.h" |
| #include "SkSRGB.h" |
| |
| static const int N = 1023; |
| |
| static uint32_t dst[N], |
| src[N]; |
| static uint8_t mask[N]; |
| |
| // We'll build up a somewhat realistic useful pipeline: |
| // - load srgb src |
| // - scale src by 8-bit mask |
| // - load srgb dst |
| // - src = srcover(dst, src) |
| // - store src back as srgb |
| |
| SK_RASTER_STAGE(load_s_srgb) { |
| auto ptr = (const uint32_t*)ctx + x; |
| |
| if (tail) { |
| float rs[] = {0,0,0,0}, |
| gs[] = {0,0,0,0}, |
| bs[] = {0,0,0,0}, |
| as[] = {0,0,0,0}; |
| for (size_t i = 0; i < (tail&3); i++) { |
| rs[i] = sk_linear_from_srgb[(ptr[i] >> 0) & 0xff]; |
| gs[i] = sk_linear_from_srgb[(ptr[i] >> 8) & 0xff]; |
| bs[i] = sk_linear_from_srgb[(ptr[i] >> 16) & 0xff]; |
| as[i] = (ptr[i] >> 24) * (1/255.0f); |
| } |
| r = Sk4f::Load(rs); |
| g = Sk4f::Load(gs); |
| b = Sk4f::Load(bs); |
| a = Sk4f::Load(as); |
| return; |
| } |
| |
| r = Sk4f{ sk_linear_from_srgb[(ptr[0] >> 0) & 0xff], |
| sk_linear_from_srgb[(ptr[1] >> 0) & 0xff], |
| sk_linear_from_srgb[(ptr[2] >> 0) & 0xff], |
| sk_linear_from_srgb[(ptr[3] >> 0) & 0xff] }; |
| |
| g = Sk4f{ sk_linear_from_srgb[(ptr[0] >> 8) & 0xff], |
| sk_linear_from_srgb[(ptr[1] >> 8) & 0xff], |
| sk_linear_from_srgb[(ptr[2] >> 8) & 0xff], |
| sk_linear_from_srgb[(ptr[3] >> 8) & 0xff] }; |
| |
| b = Sk4f{ sk_linear_from_srgb[(ptr[0] >> 16) & 0xff], |
| sk_linear_from_srgb[(ptr[1] >> 16) & 0xff], |
| sk_linear_from_srgb[(ptr[2] >> 16) & 0xff], |
| sk_linear_from_srgb[(ptr[3] >> 16) & 0xff] }; |
| a = SkNx_cast<float>((Sk4i::Load(ptr) >> 24) & 0xff) * (1/255.0f); |
| } |
| |
| SK_RASTER_STAGE(load_d_srgb) { |
| auto ptr = (const uint32_t*)ctx + x; |
| |
| if (tail) { |
| float rs[] = {0,0,0,0}, |
| gs[] = {0,0,0,0}, |
| bs[] = {0,0,0,0}, |
| as[] = {0,0,0,0}; |
| for (size_t i = 0; i < (tail&3); i++) { |
| rs[i] = sk_linear_from_srgb[(ptr[i] >> 0) & 0xff]; |
| gs[i] = sk_linear_from_srgb[(ptr[i] >> 8) & 0xff]; |
| bs[i] = sk_linear_from_srgb[(ptr[i] >> 16) & 0xff]; |
| as[i] = (ptr[i] >> 24) * (1/255.0f); |
| } |
| dr = Sk4f::Load(rs); |
| dg = Sk4f::Load(gs); |
| db = Sk4f::Load(bs); |
| da = Sk4f::Load(as); |
| return; |
| } |
| |
| dr = Sk4f{ sk_linear_from_srgb[(ptr[0] >> 0) & 0xff], |
| sk_linear_from_srgb[(ptr[1] >> 0) & 0xff], |
| sk_linear_from_srgb[(ptr[2] >> 0) & 0xff], |
| sk_linear_from_srgb[(ptr[3] >> 0) & 0xff] }; |
| |
| dg = Sk4f{ sk_linear_from_srgb[(ptr[0] >> 8) & 0xff], |
| sk_linear_from_srgb[(ptr[1] >> 8) & 0xff], |
| sk_linear_from_srgb[(ptr[2] >> 8) & 0xff], |
| sk_linear_from_srgb[(ptr[3] >> 8) & 0xff] }; |
| |
| db = Sk4f{ sk_linear_from_srgb[(ptr[0] >> 16) & 0xff], |
| sk_linear_from_srgb[(ptr[1] >> 16) & 0xff], |
| sk_linear_from_srgb[(ptr[2] >> 16) & 0xff], |
| sk_linear_from_srgb[(ptr[3] >> 16) & 0xff] }; |
| |
| da = SkNx_cast<float>((Sk4i::Load(ptr) >> 24) & 0xff) * (1/255.0f); |
| } |
| |
| SK_RASTER_STAGE(scale_u8) { |
| auto ptr = (const uint8_t*)ctx + x; |
| |
| Sk4b cov; |
| |
| if (tail) { |
| uint8_t cs[] = {0,0,0,0}; |
| switch (tail&3) { |
| case 3: cs[2] = ptr[2]; |
| case 2: cs[1] = ptr[1]; |
| case 1: cs[0] = ptr[0]; |
| } |
| cov = Sk4b::Load(cs); |
| } else { |
| cov = Sk4b::Load(ptr); |
| } |
| |
| auto c = SkNx_cast<float>(cov) * (1/255.0f); |
| r *= c; |
| g *= c; |
| b *= c; |
| a *= c; |
| } |
| |
| SK_RASTER_STAGE(srcover) { |
| auto A = 1.0f - a; |
| r += dr * A; |
| g += dg * A; |
| b += db * A; |
| a += da * A; |
| } |
| |
| SK_RASTER_STAGE(store_srgb) { |
| auto ptr = (uint32_t*)ctx + x; |
| |
| uint32_t* dst = nullptr; |
| uint32_t stack[4]; |
| |
| if (tail) { |
| dst = ptr; |
| ptr = stack; |
| } |
| |
| ( sk_linear_to_srgb(r) |
| | sk_linear_to_srgb(g) << 8 |
| | sk_linear_to_srgb(b) << 16 |
| | Sk4f_round(255.0f*a) << 24).store(ptr); |
| |
| switch (tail&3) { |
| case 3: dst[2] = ptr[2]; |
| case 2: dst[1] = ptr[1]; |
| case 1: dst[0] = ptr[0]; |
| } |
| } |
| |
| class SkRasterPipelineBench : public Benchmark { |
| public: |
| SkRasterPipelineBench(bool fused) : fFused(fused) {} |
| |
| bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; } |
| const char* onGetName() override { return fFused ? "SkRasterPipelineBench_fused" |
| : "SkRasterPipelineBench_pipeline"; } |
| |
| void onDraw(int loops, SkCanvas*) override { |
| while (loops --> 0) { |
| fFused ? this->runFused() : this->runPipeline(); |
| } |
| } |
| |
| void runFused() { |
| Sk4f r,g,b,a, dr,dg,db,da; |
| size_t x = 0, n = N; |
| while (n >= 4) { |
| load_s_srgb(src , x,0, r,g,b,a, dr,dg,db,da); |
| scale_u8 (mask , x,0, r,g,b,a, dr,dg,da,da); |
| load_d_srgb(dst , x,0, r,g,b,a, dr,dg,da,da); |
| srcover (nullptr, x,0, r,g,b,a, dr,dg,da,da); |
| store_srgb (dst , x,0, r,g,b,a, dr,dg,da,da); |
| |
| x += 4; |
| n -= 4; |
| } |
| if (n > 0) { |
| load_s_srgb(src , x,n, r,g,b,a, dr,dg,db,da); |
| scale_u8 (mask , x,n, r,g,b,a, dr,dg,da,da); |
| load_d_srgb(dst , x,n, r,g,b,a, dr,dg,da,da); |
| srcover (nullptr, x,n, r,g,b,a, dr,dg,da,da); |
| store_srgb (dst , x,n, r,g,b,a, dr,dg,da,da); |
| } |
| } |
| |
| void runPipeline() { |
| SkRasterPipeline p; |
| p.append<load_s_srgb>(src); |
| p.append< scale_u8>(mask); |
| p.append<load_d_srgb>(dst); |
| p.append< srcover>(); |
| p.last < store_srgb>(dst); |
| p.run(N); |
| } |
| |
| bool fFused; |
| }; |
| |
| DEF_BENCH( return new SkRasterPipelineBench(true); ) |
| DEF_BENCH( return new SkRasterPipelineBench(false); ) |