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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_VIZ_SERVICE_DISPLAY_SKIA_OUTPUT_SURFACE_H_
#define COMPONENTS_VIZ_SERVICE_DISPLAY_SKIA_OUTPUT_SURFACE_H_
#include <memory>
#include <vector>
#include "build/build_config.h"
#include "components/viz/common/quads/aggregated_render_pass.h"
#include "components/viz/common/resources/resource_format.h"
#include "components/viz/common/resources/resource_id.h"
#include "components/viz/service/display/external_use_client.h"
#include "components/viz/service/display/output_surface.h"
#include "components/viz/service/display/overlay_processor_interface.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "third_party/skia/include/core/SkYUVAInfo.h"
#if BUILDFLAG(IS_WIN)
#include "components/viz/service/display/dc_layer_overlay.h"
#endif
#if BUILDFLAG(IS_APPLE)
#include "components/viz/service/display/ca_layer_overlay.h"
#endif
class SkCanvas;
class SkImage;
#if BUILDFLAG(IS_APPLE)
class SkDeferredDisplayList;
#endif
namespace gfx {
class ColorSpace;
} // namespace gfx
namespace viz {
class OverlayCandidate;
class ContextLostObserver;
class CopyOutputRequest;
namespace copy_output {
struct RenderPassGeometry;
} // namespace copy_output
// This class extends the OutputSurface for SkiaRenderer needs. In future, the
// SkiaRenderer will be the only renderer. When other renderers are removed,
// we will replace OutputSurface with SkiaOutputSurface, and remove all
// OutputSurface's methods which are not useful for SkiaRenderer.
class VIZ_SERVICE_EXPORT SkiaOutputSurface : public OutputSurface,
public ExternalUseClient {
public:
#if BUILDFLAG(IS_ANDROID)
using OverlayList = std::vector<OverlayCandidate>;
#elif BUILDFLAG(IS_APPLE)
using OverlayList = CALayerOverlayList;
#elif BUILDFLAG(IS_WIN)
using OverlayList = DCLayerOverlayList;
#elif defined(USE_OZONE)
using OverlayList = std::vector<OverlayCandidate>;
#else
// Default.
using OverlayList = std::vector<OverlayCandidate>;
#endif
explicit SkiaOutputSurface(OutputSurface::Type type);
SkiaOutputSurface(const SkiaOutputSurface&) = delete;
SkiaOutputSurface& operator=(const SkiaOutputSurface&) = delete;
~SkiaOutputSurface() override;
SkiaOutputSurface* AsSkiaOutputSurface() override;
// Begin painting the current frame. This method will create a
// SkDeferredDisplayListRecorder and return a SkCanvas of it.
// The SkiaRenderer will use this SkCanvas to paint the current
// frame.
// And this SkCanvas may become invalid, when FinishPaintCurrentFrame is
// called.
virtual SkCanvas* BeginPaintCurrentFrame() = 0;
// Make a promise SkImage from the given |image_context|. The SkiaRenderer can
// use the image with SkCanvas returned by |GetSkCanvasForCurrentFrame|, but
// Skia will not read the content of the resource until the |sync_token| in
// the |image_context| is satisfied. The SwapBuffers should take care of this
// by scheduling a GPU task with all resource sync tokens recorded by
// MakePromiseSkImage for the current frame.
virtual void MakePromiseSkImage(
ExternalUseClient::ImageContext* image_context) = 0;
// Make a promise SkImage from the given |contexts| and |image_color_space|.
// The number of contexts provided should match the number of planes indicated
// by plane_config.
virtual sk_sp<SkImage> MakePromiseSkImageFromYUV(
const std::vector<ExternalUseClient::ImageContext*>& contexts,
sk_sp<SkColorSpace> image_color_space,
SkYUVAInfo::PlaneConfig plane_config,
SkYUVAInfo::Subsampling subsampling) = 0;
// Called if SwapBuffers() will be skipped.
virtual void SwapBuffersSkipped(const gfx::Rect root_pass_damage_rect) = 0;
// TODO(weiliangc): This API should move to OverlayProcessor.
// Schedule |output_surface_plane| as an overlay plane to be displayed.
virtual void ScheduleOutputSurfaceAsOverlay(
OverlayProcessorInterface::OutputSurfaceOverlayPlane
output_surface_plane) = 0;
// Begin painting a render pass. This method will create a
// SkDeferredDisplayListRecorder and return a SkCanvas of it. The SkiaRenderer
// will use this SkCanvas to paint the render pass.
// Note: BeginPaintRenderPass cannot be called without finishing the prior
// paint render pass.
virtual SkCanvas* BeginPaintRenderPass(const AggregatedRenderPassId& id,
const gfx::Size& size,
ResourceFormat format,
bool mipmap,
sk_sp<SkColorSpace> color_space,
const gpu::Mailbox& mailbox) = 0;
// Finish painting the current frame or current render pass, depends on which
// BeginPaint function is called last. This method will schedule a GPU task to
// play the DDL back on GPU thread on a cached SkSurface.
// Optionally the caller may specify |on_finished| callback to be called after
// the GPU has finished processing all submitted commands. The callback may be
// called on a different thread.
virtual void EndPaint(base::OnceClosure on_finished) = 0;
// Make a promise SkImage from a render pass id. The render pass has been
// painted with BeginPaintRenderPass and FinishPaintRenderPass. The format
// and mipmap must match arguments used for BeginPaintRenderPass() to paint
// this render pass.
virtual sk_sp<SkImage> MakePromiseSkImageFromRenderPass(
const AggregatedRenderPassId& id,
const gfx::Size& size,
ResourceFormat format,
bool mipmap,
sk_sp<SkColorSpace> color_space,
const gpu::Mailbox& mailbox) = 0;
// Remove cached resources generated by BeginPaintRenderPass and
// FinishPaintRenderPass.
virtual void RemoveRenderPassResource(
std::vector<AggregatedRenderPassId> ids) = 0;
// Copy the output of the current frame if the |id| is zero, otherwise copy
// the output of a cached SkSurface for the given |id|.
virtual void CopyOutput(AggregatedRenderPassId id,
const copy_output::RenderPassGeometry& geometry,
const gfx::ColorSpace& color_space,
std::unique_ptr<CopyOutputRequest> request,
const gpu::Mailbox& mailbox) = 0;
// Schedule drawing overlays at next SwapBuffers() call. Waits on
// |sync_tokens| for the overlay textures to be ready before scheduling.
// Optionally the caller may specify |on_finished| callback to be called after
// the GPU has finished processing all submitted commands. The callback may be
// called on a different thread.
virtual void ScheduleOverlays(OverlayList overlays,
std::vector<gpu::SyncToken> sync_tokens,
base::OnceClosure on_finished) = 0;
// Add context lost observer.
virtual void AddContextLostObserver(ContextLostObserver* observer) = 0;
// Remove context lost observer.
virtual void RemoveContextLostObserver(ContextLostObserver* observer) = 0;
// Only used for SkiaOutputSurfaceImpl unit tests.
virtual void ScheduleGpuTaskForTesting(
base::OnceClosure callback,
std::vector<gpu::SyncToken> sync_tokens) = 0;
// Android specific, asks GLSurfaceEGLSurfaceControl to not detach child
// surface controls during destruction. This is necessary for cases when we
// switch from chrome to other app, the OS will take care of the cleanup.
virtual void PreserveChildSurfaceControls() = 0;
// Flush pending GPU tasks. This method returns a sync token which can be
// waited on in a command buffer to ensure all pending tasks are executed on
// the GPU main thread.
virtual gpu::SyncToken Flush() = 0;
// Only used for creating and destroying shared images for render passes
virtual gpu::SharedImageInterface* GetSharedImageInterface() = 0;
// Notify OutputSurface that Display has started and stopped observing
// begin frames. Used to estimate when rendering becomes idle.
virtual void OnObservingBeginFrameSourceChanged(bool observing) = 0;
#if BUILDFLAG(IS_APPLE) || defined(USE_OZONE)
virtual SkCanvas* BeginPaintRenderPassOverlay(
const gfx::Size& size,
ResourceFormat format,
bool mipmap,
sk_sp<SkColorSpace> color_space) = 0;
virtual sk_sp<SkDeferredDisplayList> EndPaintRenderPassOverlay() = 0;
#endif
};
} // namespace viz
#endif // COMPONENTS_VIZ_SERVICE_DISPLAY_SKIA_OUTPUT_SURFACE_H_
|
