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