1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef WrappedBenchmark_DEFINED
#define WrappedBenchmark_DEFINED
#include "Benchmark.h"
#include "SkDevice.h"
#include "SkSurface.h"
#include "GrContext.h"
#include "GrRenderTarget.h"
// Wrap some other benchmark to allow specialization to either
// cpu or gpu backends. The derived class will override 'setupOffScreen'
// to create an offscreen surface in which the actual rendering will occur.
class WrappedBenchmark : public Benchmark {
public:
// Takes ownership of caller's ref on `bench`.
explicit WrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* bench)
: fSurfaceProps(surfaceProps)
, fBench(bench) {}
const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; }
const char* onGetName() override { return fBench->getName(); }
const char* onGetUniqueName() override { return fBench->getUniqueName(); }
void onDelayedSetup() override { fBench->delayedSetup(); }
void onPerCanvasPreDraw(SkCanvas* canvas) override {
this->setupOffScreen(canvas);
fOffScreen->getCanvas()->clear(SK_ColorWHITE);
fBench->perCanvasPreDraw(fOffScreen->getCanvas());
}
void onPreDraw(SkCanvas* canvas) override {
SkASSERT(fOffScreen.get());
fBench->preDraw(fOffScreen->getCanvas());
}
void onPostDraw(SkCanvas* canvas) override {
SkASSERT(fOffScreen.get());
fBench->postDraw(fOffScreen->getCanvas());
}
void onPerCanvasPostDraw(SkCanvas* canvas) override {
SkASSERT(fOffScreen.get());
fBench->perCanvasPostDraw(fOffScreen->getCanvas());
}
void onDraw(int loops, SkCanvas* canvas) override {
SkASSERT(fOffScreen.get());
fBench->draw(loops, fOffScreen->getCanvas());
this->blitToScreen(canvas);
}
virtual SkIPoint onGetSize() override { return fBench->getSize(); }
protected:
virtual void setupOffScreen(SkCanvas*)=0;
void blitToScreen(SkCanvas* canvas) {
int w = SkTMin(fBench->getSize().fX, fOffScreen->width());
int h = SkTMin(fBench->getSize().fY, fOffScreen->width());
this->onBlitToScreen(canvas, w, h);
}
virtual void onBlitToScreen(SkCanvas* canvas, int w, int h) = 0;
SkSurfaceProps fSurfaceProps;
SkAutoTUnref<SkSurface> fOffScreen;
SkAutoTUnref<Benchmark> fBench;
};
// Create a raster surface for off screen rendering
class CpuWrappedBenchmark : public WrappedBenchmark {
public:
explicit CpuWrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* bench)
: INHERITED(surfaceProps, bench) {}
private:
void setupOffScreen(SkCanvas* canvas) override {
fOffScreen.reset(SkSurface::NewRaster(canvas->imageInfo(), &this->surfaceProps()));
}
void onBlitToScreen(SkCanvas* canvas, int w, int h) override {
sk_sp<SkImage> image(fOffScreen->makeImageSnapshot());
SkPaint blitPaint;
blitPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
canvas->drawImageRect(image.get(), SkIRect::MakeWH(w, h),
SkRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h)), &blitPaint);
}
typedef WrappedBenchmark INHERITED;
};
// Create an MSAA & NVPR-enabled GPU backend
class GpuWrappedBenchmark : public WrappedBenchmark {
public:
explicit GpuWrappedBenchmark(const SkSurfaceProps& surfaceProps, Benchmark* bench,
int numSamples)
: INHERITED(surfaceProps, bench)
, fNumSamples(numSamples) {}
private:
void setupOffScreen(SkCanvas* canvas) override {
fOffScreen.reset(SkSurface::NewRenderTarget(canvas->getGrContext(),
SkBudgeted::kNo,
canvas->imageInfo(),
fNumSamples,
&this->surfaceProps()));
}
void onBlitToScreen(SkCanvas* canvas, int w, int h) override {
// We call copySurface directly on the underlying GPU surfaces for a more efficient blit.
GrRenderTarget* dst, *src;
SkCanvas::LayerIter canvasIter(canvas, false);
SkAssertResult((dst = canvasIter.device()->accessRenderTarget()));
SkCanvas::LayerIter offscreenIter(fOffScreen->getCanvas(), false);
SkAssertResult((src = offscreenIter.device()->accessRenderTarget()));
SkASSERT(dst->getContext() == src->getContext());
dst->getContext()->copySurface(dst, src, SkIRect::MakeWH(w, h), SkIPoint::Make(0, 0));
#ifdef SK_DEBUG
// This method should not be called while layers are saved.
canvasIter.next();
SkASSERT(canvasIter.done());
offscreenIter.next();
SkASSERT(offscreenIter.done());
#endif
}
int fNumSamples;
typedef WrappedBenchmark INHERITED;
};
#endif //WrappedBenchmark_DEFINED
|
